{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Analysis of effects of code cleaning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_autopct(values):\n",
    "    def my_autopct(pct):\n",
    "        total = sum(values)\n",
    "        val = int(round(pct*total/100.0))\n",
    "        return '{p:.2f}%  ({v:d})'.format(p=pct,v=val)\n",
    "    return my_autopct"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from matplotlib import rc\n",
    "import pandas as pd\n",
    "\n",
    "# plot style\n",
    "sns.set_style('whitegrid')\n",
    "sns.set_style({'font.family': 'Times New Roman'})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_32_noenv = pd.read_csv(\"data/one-hour-run-data/run_log_r32_no_env.csv\", sep=\"\\t\", names=[\"doi\", \"file\", \"result\"])\n",
    "df_32_env = pd.read_csv(\"data/one-hour-run-data/run_log_r32_env.csv\", sep=\"\\t\", names=[\"doi\", \"file\", \"result\"])\n",
    "df_36_noenv = pd.read_csv(\"data/one-hour-run-data/run_log_r36_no_env.csv\", sep=\"\\t\", names=[\"doi\", \"file\", \"result\"])\n",
    "df_36_env = pd.read_csv(\"data/one-hour-run-data/run_log_r36_env.csv\", sep=\"\\t\", names=[\"doi\", \"file\", \"result\"])\n",
    "df_40_noenv = pd.read_csv(\"data/one-hour-run-data/run_log_r40_no_env.csv\", sep=\"\\t\", names=[\"doi\", \"file\", \"result\"])\n",
    "df_40_env = pd.read_csv(\"data/one-hour-run-data/run_log_r40_env.csv\", sep=\"\\t\", names=[\"doi\", \"file\", \"result\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Merging before and after datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_36 = pd.merge(df_36_noenv, df_36_env,on=['doi','file'], how='inner')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_32 = pd.merge(df_32_noenv, df_32_env,on=['doi','file'], how='inner')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_40 = pd.merge(df_40_noenv, df_40_env,on=['doi','file'], how='inner')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Remove NAN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 229,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_36.result_y.isna().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 230,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_40.result_y.isna().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_32= df_32.drop(\n",
    "    df_32[(df_32.result_x == 'time limit exceeded') | (df_32.result_y == 'time limit exceeded')].index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_36= df_36.drop(\n",
    "    df_36[(df_36.result_x == 'time limit exceeded') | (df_36.result_y == 'time limit exceeded')].index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_40= df_40.drop(\n",
    "    df_40[(df_40.result_x == 'time limit exceeded') | (df_40.result_y == 'time limit exceeded')].index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Count success"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {},
   "outputs": [],
   "source": [
    "def success(el):\n",
    "    if \"success\" in el:\n",
    "        return 1\n",
    "    return 0\n",
    "\n",
    "df_32['before']=df_32[\"result_x\"].apply(success)\n",
    "df_32['after']=df_32[\"result_y\"].apply(success)\n",
    "df_36['before']=df_36[\"result_x\"].apply(success)\n",
    "df_36['after']=df_36[\"result_y\"].apply(success)\n",
    "df_40['before']=df_40[\"result_x\"].apply(success)\n",
    "df_40['after']=df_40[\"result_y\"].apply(success)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bad code cleaning\n",
    "\n",
    "A check if there are cases where code cleaning caused error (ie where the code was successful before and had error after)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 289,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "5\n",
      "16\n"
     ]
    }
   ],
   "source": [
    "print(len(df_32[(df_32['before'] == 1) & (df_32['after'] == 0)]))\n",
    "print(len(df_36[(df_36['before'] == 1) & (df_36['after'] == 0)]))\n",
    "print(len(df_40[(df_40['before'] == 1) & (df_40['after'] == 0)]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Temp table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[12.709251101321586, 16.424822476072862, 14.843188891548959]"
      ]
     },
     "execution_count": 235,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bars1 = [\n",
    "    df_32.before.sum()*100./len(df_32),\n",
    "    df_36.before.sum()*100./len(df_36),\n",
    "    df_40.before.sum()*100./len(df_40)\n",
    "]\n",
    "bars1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[18.303964757709252, 24.51373880827416, 22.59995211874551]"
      ]
     },
     "execution_count": 236,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bars2 = [\n",
    "    df_32.after.sum()*100./len(df_32),\n",
    "    df_36.after.sum()*100./len(df_36),\n",
    "    df_40.after.sum()*100./len(df_40)\n",
    "]\n",
    "bars2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "barWidth = 0.3\n",
    "\n",
    "# The x position of bars\n",
    "r1 = np.arange(len(bars1))\n",
    "r2 = [x + barWidth for x in r1]\n",
    " \n",
    "# Create blue bars\n",
    "plt.bar(r1, bars1, width = barWidth, color = 'blue', edgecolor = 'black', capsize=7, label='before code cleaning')\n",
    " \n",
    "# Create cyan bars\n",
    "plt.bar(r2, bars2, width = barWidth, color = 'cyan', edgecolor = 'black', capsize=7, label='after code cleaning')\n",
    " \n",
    "# general layout\n",
    "plt.title(\"Success rate before and after code cleaning\")\n",
    "plt.xticks([r + barWidth/2 for r in range(len(bars1))], ['R 3.2', 'R 3.6', 'R 4.0'])\n",
    "plt.ylabel('Percentage (%)')\n",
    "plt.legend()\n",
    " \n",
    "# Show graphic\n",
    "plt.savefig('plots/before_after_code_cleaning.png', bbox_inches = \"tight\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Aggregate results from these"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 272,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1781"
      ]
     },
     "execution_count": 272,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp = pd.merge(df_32, df_36, on=['doi','file'])\n",
    "temp = pd.merge(temp, df_40, on=['doi','file'])\n",
    "len(temp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 273,
   "metadata": {},
   "outputs": [],
   "source": [
    "temp['before_ag'] = temp[['before_x','before_y','before']].max(axis=1)\n",
    "temp['after_ag'] = temp[['after_x','after_y','after']].max(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 274,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "359"
      ]
     },
     "execution_count": 274,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(temp['before_ag'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 275,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "491"
      ]
     },
     "execution_count": 275,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(temp['after_ag'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Before and after code cleaning for aggregate results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 292,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7414"
      ]
     },
     "execution_count": 292,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df1 = pd.read_csv(\"aggregate_results_env.csv\", index_col=0)\n",
    "len(df1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 293,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7659"
      ]
     },
     "execution_count": 293,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2 = pd.read_csv(\"aggregate_results_no_env.csv\", index_col=0)\n",
    "len(df2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 294,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>doi</th>\n",
       "      <th>file</th>\n",
       "      <th>r32</th>\n",
       "      <th>r36</th>\n",
       "      <th>r40</th>\n",
       "      <th>result</th>\n",
       "      <th>success</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>doi:10.7910/DVN/XFQZI2</td>\n",
       "      <td>Condemnation.R</td>\n",
       "      <td>Error in library(readstata13) : there is no pa...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>doi:10.7910/DVN/WGPDBS</td>\n",
       "      <td>Replication_of_Figures.R</td>\n",
       "      <td>success</td>\n",
       "      <td>success</td>\n",
       "      <td>success</td>\n",
       "      <td>success</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>doi:10.7910/DVN/BPON3K</td>\n",
       "      <td>fig_10_effect_of_winning_on_gov.R</td>\n",
       "      <td>Error in library(gridExtra) : there is no pack...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Error in library(gridExtra) : there is no pack...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>doi:10.7910/DVN/BPON3K</td>\n",
       "      <td>fig_11_rd_placebo.R</td>\n",
       "      <td>Error in library(gridExtra) : there is no pack...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Error in library(gridExtra) : there is no pack...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>doi:10.7910/DVN/BPON3K</td>\n",
       "      <td>fig_12_historical_trend.R</td>\n",
       "      <td>Error in library(ggthemes) : there is no packa...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Error in library(ggthemes) : there is no packa...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                      doi                               file  \\\n",
       "0  doi:10.7910/DVN/XFQZI2                     Condemnation.R   \n",
       "1  doi:10.7910/DVN/WGPDBS           Replication_of_Figures.R   \n",
       "2  doi:10.7910/DVN/BPON3K  fig_10_effect_of_winning_on_gov.R   \n",
       "3  doi:10.7910/DVN/BPON3K                fig_11_rd_placebo.R   \n",
       "4  doi:10.7910/DVN/BPON3K          fig_12_historical_trend.R   \n",
       "\n",
       "                                                 r32      r36  \\\n",
       "0  Error in library(readstata13) : there is no pa...      NaN   \n",
       "1                                            success  success   \n",
       "2  Error in library(gridExtra) : there is no pack...      NaN   \n",
       "3  Error in library(gridExtra) : there is no pack...      NaN   \n",
       "4  Error in library(ggthemes) : there is no packa...      NaN   \n",
       "\n",
       "                                                 r40   result  success  \n",
       "0                                                NaN      NaN      NaN  \n",
       "1                                            success  success      1.0  \n",
       "2  Error in library(gridExtra) : there is no pack...      NaN      NaN  \n",
       "3  Error in library(gridExtra) : there is no pack...      NaN      NaN  \n",
       "4  Error in library(ggthemes) : there is no packa...      NaN      NaN  "
      ]
     },
     "execution_count": 294,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 295,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_merged = pd.merge(df1, df2,on=['doi','file'], how='inner')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 296,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6464"
      ]
     },
     "execution_count": 296,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(df_merged)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 297,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>doi</th>\n",
       "      <th>file</th>\n",
       "      <th>r32_x</th>\n",
       "      <th>r36_x</th>\n",
       "      <th>r40_x</th>\n",
       "      <th>result_x</th>\n",
       "      <th>success_x</th>\n",
       "      <th>r32_y</th>\n",
       "      <th>r36_y</th>\n",
       "      <th>r40_y</th>\n",
       "      <th>result_y</th>\n",
       "      <th>success_y</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>doi:10.7910/DVN/XFQZI2</td>\n",
       "      <td>Condemnation.R</td>\n",
       "      <td>Error in eval(expr, envir, enclos) : could not...</td>\n",
       "      <td>Error in read.dta13('Condemnation.dta') :   co...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Error in library(readstata13) : there is no pa...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>doi:10.7910/DVN/WGPDBS</td>\n",
       "      <td>Replication_of_Figures.R</td>\n",
       "      <td>success</td>\n",
       "      <td>success</td>\n",
       "      <td>success</td>\n",
       "      <td>success</td>\n",
       "      <td>1.0</td>\n",
       "      <td>success</td>\n",
       "      <td>success</td>\n",
       "      <td>success</td>\n",
       "      <td>success</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>doi:10.7910/DVN/BPON3K</td>\n",
       "      <td>fig_10_effect_of_winning_on_gov.R</td>\n",
       "      <td>Error in diag(vcovHC(DMareg, type = 'HC3')) : ...</td>\n",
       "      <td>Error in vcovHC(DMareg, type = 'HC3') : could ...</td>\n",
       "      <td>Error in vcovHC(DMareg, type = 'HC3') : could ...</td>\n",
       "      <td>Error in vcovHC(DMareg, type = 'HC3') : could ...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>Error in library(gridExtra) : there is no pack...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Error in library(gridExtra) : there is no pack...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>doi:10.7910/DVN/BPON3K</td>\n",
       "      <td>fig_11_rd_placebo.R</td>\n",
       "      <td>Error in ggsave('placebo.pdf', plot = placebo,...</td>\n",
       "      <td>success</td>\n",
       "      <td>success</td>\n",
       "      <td>success</td>\n",
       "      <td>1.0</td>\n",
       "      <td>Error in library(gridExtra) : there is no pack...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Error in library(gridExtra) : there is no pack...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>doi:10.7910/DVN/BPON3K</td>\n",
       "      <td>fig_12_historical_trend.R</td>\n",
       "      <td>Error in ggsave('historical_trend.pdf', plot =...</td>\n",
       "      <td>success</td>\n",
       "      <td>success</td>\n",
       "      <td>success</td>\n",
       "      <td>1.0</td>\n",
       "      <td>Error in library(ggthemes) : there is no packa...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>Error in library(ggthemes) : there is no packa...</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                      doi                               file  \\\n",
       "0  doi:10.7910/DVN/XFQZI2                     Condemnation.R   \n",
       "1  doi:10.7910/DVN/WGPDBS           Replication_of_Figures.R   \n",
       "2  doi:10.7910/DVN/BPON3K  fig_10_effect_of_winning_on_gov.R   \n",
       "3  doi:10.7910/DVN/BPON3K                fig_11_rd_placebo.R   \n",
       "4  doi:10.7910/DVN/BPON3K          fig_12_historical_trend.R   \n",
       "\n",
       "                                               r32_x  \\\n",
       "0  Error in eval(expr, envir, enclos) : could not...   \n",
       "1                                            success   \n",
       "2  Error in diag(vcovHC(DMareg, type = 'HC3')) : ...   \n",
       "3  Error in ggsave('placebo.pdf', plot = placebo,...   \n",
       "4  Error in ggsave('historical_trend.pdf', plot =...   \n",
       "\n",
       "                                               r36_x  \\\n",
       "0  Error in read.dta13('Condemnation.dta') :   co...   \n",
       "1                                            success   \n",
       "2  Error in vcovHC(DMareg, type = 'HC3') : could ...   \n",
       "3                                            success   \n",
       "4                                            success   \n",
       "\n",
       "                                               r40_x  \\\n",
       "0                                                NaN   \n",
       "1                                            success   \n",
       "2  Error in vcovHC(DMareg, type = 'HC3') : could ...   \n",
       "3                                            success   \n",
       "4                                            success   \n",
       "\n",
       "                                            result_x  success_x  \\\n",
       "0                                                NaN        NaN   \n",
       "1                                            success        1.0   \n",
       "2  Error in vcovHC(DMareg, type = 'HC3') : could ...        0.0   \n",
       "3                                            success        1.0   \n",
       "4                                            success        1.0   \n",
       "\n",
       "                                               r32_y    r36_y  \\\n",
       "0  Error in library(readstata13) : there is no pa...      NaN   \n",
       "1                                            success  success   \n",
       "2  Error in library(gridExtra) : there is no pack...      NaN   \n",
       "3  Error in library(gridExtra) : there is no pack...      NaN   \n",
       "4  Error in library(ggthemes) : there is no packa...      NaN   \n",
       "\n",
       "                                               r40_y result_y  success_y  \n",
       "0                                                NaN      NaN        NaN  \n",
       "1                                            success  success        1.0  \n",
       "2  Error in library(gridExtra) : there is no pack...      NaN        NaN  \n",
       "3  Error in library(gridExtra) : there is no pack...      NaN        NaN  \n",
       "4  Error in library(ggthemes) : there is no packa...      NaN        NaN  "
      ]
     },
     "execution_count": 297,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_merged.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 298,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_merged= df_merged.drop(\n",
    "    df_merged[(df_merged.result_x == 'time limit exceeded') | (df_merged.result_y == 'time limit exceeded')].index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 299,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_merged= df_merged.drop(\n",
    "    df_merged[(df_merged.result_x.isna()) | (df_merged.result_y.isna())].index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 300,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2335"
      ]
     },
     "execution_count": 300,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(df_merged)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 311,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "# * bad code cleaning\n",
    "print(len(df_merged[(df_merged['success_x'] == 0) & (df_merged['success_y'] == 1)]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 304,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2335"
      ]
     },
     "execution_count": 304,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(df_merged)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[12.709251101321586,\n",
       " 16.424822476072862,\n",
       " 14.843188891548959,\n",
       " 36.102783725910065]"
      ]
     },
     "execution_count": 247,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bars1 = [\n",
    "    df_32.before.sum()*100./len(df_32),\n",
    "    df_36.before.sum()*100./len(df_36),\n",
    "    df_40.before.sum()*100./len(df_40),\n",
    "    (df_merged['result_y'] == 'success').sum()*100./len(df_merged)\n",
    "]\n",
    "bars1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[18.303964757709252, 24.51373880827416, 22.59995211874551, 46.980728051391864]"
      ]
     },
     "execution_count": 248,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bars2 = [\n",
    "    df_32.after.sum()*100./len(df_32),\n",
    "    df_36.after.sum()*100./len(df_36),\n",
    "    df_40.after.sum()*100./len(df_40),\n",
    "    (df_merged['result_x'] == 'success').sum()*100./len(df_merged)\n",
    "]\n",
    "bars2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "metadata": {},
   "outputs": [],
   "source": [
    "totals = [len(df_32), len(df_36), len(df_40), len(df_merged)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "barWidth = 0.3\n",
    "\n",
    "plt.figure(figsize=(12,5))\n",
    "\n",
    "# The x position of bars\n",
    "r1 = np.arange(len(bars1))\n",
    "r2 = [x + barWidth for x in r1]\n",
    " \n",
    "# Create blue bars\n",
    "plt.bar(r1, bars1, width = barWidth, color = 'blue', edgecolor = 'black', capsize=7, label='before code cleaning')\n",
    " \n",
    "# Create cyan bars\n",
    "plt.bar(r2, bars2, width = barWidth, color = 'cyan', edgecolor = 'black', capsize=7, label='after code cleaning')\n",
    "\n",
    "bbox_props = dict(boxstyle=\"square,pad=0.3\", fc=\"w\", ec=\"k\", lw=1)\n",
    "for i in range(len(totals)):\n",
    "    plt.annotate(\"(\"+str(int(totals[i]))+\")\", xy=(i+0.05, 2), bbox=bbox_props, rotation=0, color=\"black\", size=12)\n",
    "\n",
    "# general layout\n",
    "plt.title(\"Success rate before and after code cleaning\", fontsize=20)\n",
    "plt.xticks([r + barWidth/2 for r in range(len(bars1))], ['R 3.2', 'R 3.6', 'R 4.0', 'Combined'], fontsize=16)\n",
    "plt.ylabel('Percentage (%)', fontsize=16)\n",
    "plt.legend(fontsize=16)\n",
    " \n",
    "# Show graphic\n",
    "plt.savefig('plots/before_after_code_cleaning2.png', bbox_inches = \"tight\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# count success values\n",
    "\n",
    "success3 = (df['result3'] == 'success').sum()\n",
    "success2 = (df['result2'] == 'success').sum()\n",
    "success = (df['result'] == 'success').sum()\n",
    "total3 = df['result3'].count()\n",
    "total2 = df['result2'].count()\n",
    "total = df['result'].count()\n",
    "\n",
    "agg_df = df.groupby(['doi']).max()\n",
    "agg_success = agg_df['agg'].sum()\n",
    "agg_total = agg_df['agg'].count()\n",
    "\n",
    "values = [\n",
    "    success2*1. / total2,\n",
    "    success3*1. / total3,\n",
    "    success*1. /total,\n",
    "    agg_success*1. / agg_total\n",
    "]\n",
    "values = [(i*100).round(2) for i in values]\n",
    "\n",
    "totals = [\n",
    "    total2, total3, total, agg_total\n",
    "]\n",
    "\n",
    "labels = [\n",
    "    \"Python 2.7\\n\\n(a)\",\n",
    "    \"Python 3.5\\n\\n(b)\",\n",
    "    \"Combined \\n(best of two)\\n(c)\",\n",
    "    \"Aggregated \\nper dataset\\n(d)\"\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 339,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from matplotlib import rc\n",
    "import pandas as pd\n",
    "# plot styles\n",
    "sns.set_style('whitegrid')\n",
    "sns.set_style({'font.family': 'Arial Unicode MS'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 340,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>totals</th>\n",
       "      <th>values</th>\n",
       "      <th>fail</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>4540</td>\n",
       "      <td>18.303965</td>\n",
       "      <td>81.696035</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>3239</td>\n",
       "      <td>24.513739</td>\n",
       "      <td>75.486261</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4177</td>\n",
       "      <td>22.599952</td>\n",
       "      <td>77.400048</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2335</td>\n",
       "      <td>46.980728</td>\n",
       "      <td>53.019272</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   totals     values       fail\n",
       "0    4540  18.303965  81.696035\n",
       "1    3239  24.513739  75.486261\n",
       "2    4177  22.599952  77.400048\n",
       "3    2335  46.980728  53.019272"
      ]
     },
     "execution_count": 340,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp_df = pd.DataFrame ({'values':bars2,'totals':totals})\n",
    "temp_df['fail'] = 100. - temp_df['values']\n",
    "temp_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 343,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnQAAAFaCAYAAACXJ8AUAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi40LCBodHRwOi8vbWF0cGxvdGxpYi5vcmcv7US4rQAAIABJREFUeJzs3XlcTun/P/BXmyXZIvsk4q5UVMiWUlK2hEaWlGxZPpYSypoZQ5gZW8xYZizZ12xjjymkwjAZolGmbGVLpL2u3x9+na9bizuUabyej4fHQ9e5znW9z7nv+5z3fc51rltJCCFAREREROWW8ucOgIiIiIg+DhM6IiIionKOCR0RERFROceEjoiIiKicY0JHREREVM4xoSMiIiIq5/6VCZ2vry/09PSK/Td+/PjPHaZCkpKS8Pr1a+nv/G2j/4bMzEw8fPiwzPuNioqCo6MjjI2N0bVrV5Rk9qH9+/dDT08PERERJe43NzcX8fHxJV6vNNy9e/ez9Hv//n3o6ekhICBArjwuLk7ubz09Pfj6+n5QH0UdAw0NDWFhYYHp06fjyZMnH7wNn9LHbOe78vLy8N1338Hc3BympqbYvn37J2n3U8p/be7fv1/o8oiIiELfH+WVjY0NXF1di60TEBBQ6Hu1U6dOGDt2LC5fvvxRMbz72aLCqX7uAIozY8YM1KxZs9Bl9evXL+NoSi40NBReXl44ePAgqlSpAgAYOHAgOnTo8Jkjo0/h4cOHGDZsGMaNG4f+/fuXad/z5s1DfHw8vL29UatWLSgpKZV6n6mpqXBzc4O1tTUmTpxY6v0VZ/jw4ahbty4WLVpU5n1rampiyZIlcl/MZs+ejfj4eGzZsuWT9vXuMTA1NRURERE4ePAgbt68iaCgIKipqX3SPj+nkJAQbNmyBZaWlrCzs0Pr1q0/d0hUAmPHjkXTpk0BvPnyl5SUhP3798PNzQ3+/v5wdHQscZv79u2Dn58f/vrrr08d7n/Ovzqhs7W1RaNGjT53GB/sr7/+QmpqqlyZqakpTE1NP1NE9Ck9fPgQCQkJn6Xvf/75B507d4a7u3uZ9ZmamoobN27A2tq6zPosSkREBPr06fNZ+lZXVy9wYoqIiEC9evU+eV+FHQNdXFzg5+eHnTt34uTJk+jVq9cn7/dz+eeffwAAU6dO5Z2Mcqhjx45o166dXJmbmxvc3NwwZ84ctG3bFg0aNChRm3/88Qeys7M/ZZj/Wf/KW65EVLyMjAzpqi99efKvCF+9evUzR/JppaenAwDf2/8hVapUwdy5c5GZmYnNmzd/7nD+08p9QhcaGgo9PT1MnjxZrnzu3LnQ09NDaGioVHbr1i2MHTsWbdq0gampKYYOHYoLFy4UaDMuLg4TJkyAubk5WrduDVdXV1y6dEla7urqChsbmwLrvV3u6+uLFStWAAC6du0qjUEobAzdvXv34O3tjfbt28PY2Bh9+vTBnj175OoEBATA1NQU8fHxGDNmDExNTWFubo7p06cjOTm52H2UkZGBpUuXomvXrmjZsiVsbGzg7+8vd/WwqLF9hZUnJSXB19cXHTt2hKmpKQYMGIDTp0+XuM7z588xd+5cWFhYwNjYGA4ODti2bZvceLC8vDz88ssvsLe3R8uWLWFpaYmZM2fi8ePHJapTmICAABgbGyM4OBgWFhZo164dDh8+DODNe2Xy5MmwsrKCkZEROnXqBC8vLyQmJgJ4Mw7NxcUFwJvbYm/vo7S0NHz//fewsbGBkZER7OzssHr1amRlZRUbT2Hr2tjY4Mcff0RGRobUr56eHnJzcxEUFAQ9PT3s37+/yPaePn2KqVOnom3btjA1NYW3tzdevnxZoN69e/cwc+ZM2NjYwNjYGO3bt8eYMWPw999/A3hzBcrKygoAsGrVKrkxRO9bN9/evXvh4OAAExMTWFhYYNKkSQXGweXk5GDt2rWwt7eHkZERunTpgkWLFknv1fzxa29vf/5YwODgYAwYMACmpqZo3749Ro0ahaioqCL3TUJCAvT09PDTTz/JlQ8ePBh6enpISkqSyuLi4qCnp4e9e/cWGEOnp6eHhIQEREZGFng9hBDYuHEjbG1tpfd4/nvsY6irqwMAVFRU3ls3JCQEQ4YMgampKTp16gRvb+8C479OnjwJZ2dntGzZEm3atMH48eNx+/btAm1t2rQJ3bp1g7GxMfr27Vvk2KiIiAi4urrC1NQUrVu3xujRo997y8zGxkbumJl/LLWxscGcOXMwd+5ctGrVCr169ZKOeRERERg2bJh058Pd3b1ATDY2Nvj222+xa9cu6XXo378/rl27hqSkJEycOBGmpqbo3LkzfvjhB+Tm5r53n36Iffv2YcCAATA3N0erVq1gb2+PdevWyR3vCttWPz8/tGjRAs+fP5drLz09HaamppgzZ85H95G/Pw8dOoTevXvD2NgY3bt3x8mTJz/Jtrdq1QoNGjTAmTNnSrRPXF1dsXfvXgAFx2q+b92S7DdFcgNXV1eMHDlSOhd37doVsbGxSE5Ohp+fH7p06SLFsWrVKuTk5Mit//Z5vlWrVvj666/x22+/feSelfevvuX68uXLAi9GvurVq0NFRQWWlpbo378/9u/fj/Pnz8PCwgIXL17Erl27MHjwYFhaWgIAoqOjMWTIENSoUQOjRo1C1apVERwcjBEjRmD58uXo0aMHACA+Ph4DBgxAhQoV4OrqCk1NTezevRvDhw/Hli1bFL5dOnDgQKSlpeHEiROYMWMGmjdvXmi9+Ph4ODs7Izs7G0OHDoWWlhZOnz6N2bNnIy4uDj4+PlLd7OxsuLm5oUOHDvD19cXVq1cRFBSE5ORkrF+/vshY5s+fjyNHjsDV1RWNGzdGXFwcAgMDkZCQgJ9//lmh7cmXnJyMgQMHIiUlBUOGDEGjRo1w9OhRTJgwAStWrIC9vb1CdV6/fg0XFxc8evQIgwcPRuPGjREVFYWFCxciNjYWc+fOBQCsWbMGAQEBGDRoEFq0aIGHDx9i8+bN0vghJSUlheoUJScnBzNnzsSwYcOQl5cHAwMDxMbGwsXFBQ0aNIC7uzuqVq2KP//8E3v27MH9+/exZ88etG3bFuPHj8dPP/2EgQMHSmN9cnNzMWbMGPzxxx9wcnJCixYtcOfOHaxfvx7Xr1/Hzz//XGQ8mZmZGDZsGK5fv47+/fvDyMgI169fx/r163H58mVs3rwZbdu2xZIlS+Dr6wszMzM4OzvDzMys0PYyMjLg5uaGR48eYcSIEahTpw4OHTpU4KD67NkzDB06FCoqKhg0aBBq1aqFv//+G9u2bcPIkSMRHBwMXV1dzJ49G9999x26deuGbt26QVNTU6F11dTUcPDgQcyaNQsODg5wc3PD8+fPERgYCHd3dxw9elS6IuPr64sjR46gV69ecHd3x6NHj7Bz505cunQJ27dvl8avvb39urq6iIyMxIQJE9C5c2f4+voiPT0d27Ztw/Dhw3Ho0CE0bNiwwP7R1taGjo4OwsPDpYes0tLScP36dQDA5cuXpduZ58+fh5KSEqysrJCZmSnXzpIlS7BkyRJUq1YNY8eOlXs9jh8/jnPnzsHV1RWVK1fGpk2bMG3aNGhra6NVq1ZFvi/fJ/9kY2BgUGy9o0ePwsvLCwYGBpg4cSJycnKwYcMGXL16Ffv370eNGjWwadMm+Pv7w8jICFOmTMHr16+xfft2DBw4EIGBgWjZsiWAN1+AVq1aBTs7O3h4eCAmJgbjxo0r0GdoaCjGjRuHpk2bYsKECVBVVcXhw4cxaNAgBAYGFvl+nTlzJg4dOiQdM9++1Xzs2DE0aNAA06dPx9OnT1GzZk0cP34cXl5e0NbWluLYt28fhg0bhhUrVsDW1lZa//fff8exY8fg7u4OZWVlrF27FhMnTkT16tXRrFkz+Pj44OzZs1i/fj0aN26MAQMGvPc1KOr89OrVqwJla9aswbJly+Do6IgBAwYgMzMTBw8exI8//ggNDQ0MGTKkyG3t1KkTdu7ciVOnTmHgwIFSvbNnzyItLQ29e/f+6D5q1qyJ/fv3Y8aMGWjXrh3c3Nzw8OFDzJgxA9nZ2YV+fkpKW1sb4eHhyMjIQKVKlRSKd+zYsQCAyMhILFmyBNra2gpvq4ODg0L7TdHcAAD+/PNP3L17F15eXnj06BG0tbUxevRoREdHw9XVFXXr1kVUVBQCAgLw4sULzJ49G8CbCxyDBg1CTk4OhgwZgjp16uDixYvw9vZGYmIiRo4c+dH7FwAg/oV8fHyETCYr9t/Nmzel+ikpKcLCwkJ069ZNPH/+XFhbW4tu3bqJ169fS3VcXV2FhYWFeP78uVxfXl5eon379iIrK0sIIYSnp6do0aKFiI2NleokJycLMzMzMXHiRCGEEEOHDhXW1tYF4n63fPXq1UImk4l79+4V2LZ8EydOFPr6+uLGjRtSWV5enpgwYYLQ09MTt2/fFkIIsXLlSiGTycTixYvl+nRxcRH6+voiLS2tyP3Zpk0bMX/+fLmy5cuXCycnJ2m9d+MqKt7vv/9eyGQyERYWJpVlZmYKW1tb0b9/f4XrBAQECH19fXH58mW5/nbs2CH3+jo6OoqxY8fK1dm5c6fo06ePuH//vsJ1CpO/T1esWCFXPn/+fGFqaipevnwpVz5lyhQhk8lEamqqEEKIS5cuCZlMJvbt2yfVCQoKEjKZTBw5ckRu3dDQUCGTycSpU6eKjGfLli1CJpOJTZs2yZVv2rRJyGQysXXrVqnMwMBA+Pj4FNnW2+sdPnxYKsvKyhI9evQQMplMhIeHCyGE2Lhxo9DT0xP//POP3PpLly4VMplMeg8+evRIyGQysXLlSqmOouuOHz9eODg4yNX5/fffRc+ePcW1a9eEEEJERkYKmUwm1q5dK1fv1q1bwtDQUGzcuLHI7V+wYIFo3bq1yMvLk8pu374t7Ozsit3n8+fPF8bGxiIzM1MIIcS5c+eETCYT5ubmws/PT6o3evRo0a9fPyGEEPfu3SuwH2xtbcXQoUPl2pbJZMLIyEju85//nlm2bFmRMQnxf5+7GzduiGfPnkn/EhISxL59+4Spqano3bu3dNwqTE5OjrCwsBD29vZyx4ewsDDp/fTs2TNhbGwsBgwYIO0DId681iYmJtLn9dmzZ8LQ0FCMGDFCro/8Y1z+a5GbmytsbW2Fg4ODXHs5OTli8ODBok+fPsVud2HHTGtrayGTyURCQoJUlpWVJTp16iS6dOkiXr16JZW/evVKdOnSRVhYWEj7Jn/96Ohoqd6yZcuETCYTnp6eUll6erowMjISkydPLjZGRc5Pb78/srOzhbm5uZg2bZpcO69evRLGxsbSeaWobc3LyxPW1tbC3d1dbv0JEyYIS0tLkZub+9F9ZGVliQ4dOoiePXuK7OxsqfzAgQNCJpMVeG+/K/9Ymn9MKYynp6eQyWQiKSmpRPHOnDlT7hyk6LqK7DchFM8Nhg4dKmQymbh48aJUJyUlRchkMrljkxBCzJgxQ+6z4uvrK0xMTAocJ3/44QdhaGgonjx5UuR+K4l/9RW677//HrVr1y50WX6mDgDVqlXDN998g3HjxsHJyQmJiYnYtm2bdFvixYsXiIiIgJubG4QQct+qLC0t8dtvv+Gvv/6CiYkJzpw5g86dO0tP6gBAjRo1sHPnTtSqVeuTbl9ubi5CQ0NhYWGBFi1aSOVKSkoYM2YMTp48iTNnzkAmk0nL7O3t5dowMjLCpUuXkJKSgsqVKxfaj5aWFk6ePAkDAwNYW1tDU1MTkydPLnCbWhHBwcGQyWRyT+pWqFAB69evl/pXpM6JEyfQokULNGnSRO716NixI4A33/INDAygpaWFyMhIbNmyBd26dUO9evUwcOBAuW9citQpjoWFhdzfM2fOxPjx41G1alWp7PXr16hYsSKAN9/Mixrjc/z4cdSqVQsdOnSQ2y5DQ0NoaGggNDRU7srB286ePYuqVavKfZMG3gyCX716NYKDg6XbvIoIDQ1F9erV0b17d6lMTU0NAwYMkHs6dNiwYXBwcJB7f2dmZkq38wq7RVvSdbW0tBASEoKff/4ZPXr0gI6ODqysrKTbuMCb94Sqqip69eolt++0tLSgo6ODc+fOFfkQiJaWFl69eoUlS5bA0dER+vr6kMlkOHHiRLH7yNLSElu2bMEff/yB9u3bIzIyErq6umjevLl06y4rKwuXLl3C8OHDi22rMG3btpW70tSyZUsoKSnh2bNnCq3fr1+/AmXVqlVDjx494OPjU+wTrn/99RceP34MHx8fuWNDhw4dsHfvXjRt2hRnz55FZmYm3N3dUaFCBalOvXr10L9/f2zduhVJSUm4dOkSsrOz4ezsLNfHoEGDsHLlSunv6OhoJCQkwMfHp8ADYRYWFlixYgUeP36MOnXqKLT9+XR0dPDVV1/JbduTJ08wdepUaGhoSOUaGhpwdXXF4sWLcf36delqoLa2NvT19aV6+eePtz+LlSpVQq1atRSeDqao89OtW7ewePFi6W9VVVX8/vvvBW7lpqSkoEqVKkhJSSl2W5WUlNC7d2/8+uuveP78OTQ1NZGamoqQkBC4uLhAWVkZysrKH9XHX3/9hWfPnmHUqFFQVf2/tKBnz55YuHChQvvjffLy8gC8GSZQ0n3yNkXXVWS/KZob5N+Zq1ixIszNzaU66urq0NDQwO7du1GnTh1YWlpCQ0NDbp8JIXDq1Cl06tQJVatWleujU6dOWLduHcLDw6Urhh/jX53QmZmZKfyUq42NDezt7XHixAlpvEi+/HmzAgMDERgYWOj6jx49QuPGjZGRkYHGjRsXWF7ULdOP8fz5c6Snp6NJkyYFluUnlO/OcaapqSn3d35i8e79+rf5+flh0qRJmDlzJpSVlWFoaIhu3brB2dm5yGlhipKYmIhOnToVKNfR0SlRnfj4eGRmZhY5hUv+dk+fPh0eHh747rvv8N1330Emk8HGxgaDBg2Spq5RpE5x3k3UlZWVkZycjK1bt+LGjRuIjY3FgwcPpLEZxY2xiY+Px7Nnz967XYV58OABGjVqVOAkraqqiq+++goPHjx477YU1t7bB2gAcl9WgDcHvqysLKxduxbXr1/HnTt3cO/ePWk7i9teRdcdN24crly5guXLl2P58uXQ1taGtbU1Bg4cCF1dXQBvnnDMyckpdHzq++JwcXFBSEgINmzYgA0bNqBu3bro0qULvv76a+mWYWHatWuHSpUqITw8HO3bt0dERATatm2L5s2b48SJE0hOTsatW7eQlpYml3wq6t0TfoUKFaCsrKzwU3v5SUNWVhbCw8OxefNm2NraYs6cOahUqVKx6z569AgACj2eGRsbA/i/9+O774m3yx4+fCjVe/szDLw5Hr19DMk/1i5evFguqXk3rpImdO8e9/Ljed+xMz+he/d1yP/C8e5nX01NTUo83qeo81Nh4xorVqyIs2fPIjQ0FH///TdiY2Px4sULACjQ37vbCgAODg5Yu3YtTp8+DWdnZ5w5cwaZmZlwcHD4JH0U9fqqqanJJX4fIyUlBSoqKtIX5ZLE+y5F133fflM0N8jPJ2rUqAFl5f979EBVVRXffvstZs+eDS8vL6iqqsLMzAx2dnZwcnKCuro6nj17hlevXuHUqVM4depUoX18qrlM/9UJXUm8fv1aGnQbEhKC169fS8lO/onYxcWlyKsjzZo1k04YHzqnV3FJVUnlvynfPRl/SGzt2rXD2bNncerUKVy4cAERERFYunQptmzZgn379qFu3bpFrvvuNuXk5Lw3BkXqCCHQunVrTJgwodDl+Qf8/BNrSEgIQkNDERERgTVr1iAwMBA7duyAvr6+QnWK8+4B+Pjx45gyZQrq1KmDDh06oEOHDmjVqhWCg4OLHauYv106Ojrw8/MrdHn16tWLXb+4dks635iSklKhJ5e3r8QAb6YFGDFiBCpXroyOHTvCyckJRkZGiIuLw7fffltsH4quW7duXRw8eBBhYWH4/fffERERgc2bN2Pbtm1Yu3YtLCwsIIRAlSpVsGrVqkL7yr9CWhh1dXVs3boVV65cwZkzZxAREYE9e/Zg165dWLBgAb7++usi22zXrh0iIiKkY4ibmxuaN28OIQSuXLmCq1evQlNTU0qCSuLtg/+HeDtp6NKlCxo0aIAFCxbg6dOnWLt2bbHtf+zxrLBj0LvHI0D+/ZR/rJ08eTJMTEwKbbewJOx9Cuu3KIrGDXz4vimpiRMn4vTp0zAzM4OJiQmcnZ3Rtm1bDB48uEDdwmJt3rw59PT0cPz4cTg7O+PYsWPQ1dWVu7PzMX3k7wdFjhcfQgiB6Oho6OrqSu2VJN53Kbru+/aborlBvsJem169eqFTp044efIkLly4gMjISERGRmLbtm0ICgqS+rC3t8egQYMK7eNTJc3/mYTuhx9+wMOHDzF9+nR8//33+PHHH6WB9fkDOlVUVKRbevnu3buHv//+G5UrV4a6ujrU1dULnQn/l19+wZMnTzBjxgxUqFChwMBo4M0ThSVRs2ZNVK5cudBZsO/cuQMAJZ6z511ZWVm4ffs26tSpA0dHR2n+rI0bN2LRokU4fvw4hg0bJn3IMjMz5U6c725To0aNCt0/QUFBuHz5MubOnatQnYYNG+L169cFXo/MzEwEBwejcePGyMvLQ0xMDNTV1aWB+MCbW3OTJk3C/v374evr+946M2fOLNE+W7p0KXR1dbFv3z65g5kik8Y2bNgQf/31F9q3b1/gZHvs2LFik+cGDRrgzz//RHZ2tlzylpWVhfj4+BJPsqqtrY2rV68iLy9PLpZ3n3AMCAiAuro6jh07JpdwhoWFvbcPRde9c+cOhBCwsLCQbnFfvXoVrq6u2LFjBywsLNCwYUOcP38ehoaGBRLfs2fPokaNGkXGkZCQgJcvX6J169bSfoqLi8OQIUOwdevWIhM64M2tlUWLFuH8+fPIycmBubk5ateuDU1NTVy+fBnh4eGwtLT86OTsU3Bzc8Ply5dx4sQJbNy4sdjB1PmJYGFzJc6YMQMmJibSFey4uLgCX3zyn1Ju2LChdIvy7t270hVV4M3n9e1blPnHWnV19QKf7ZiYGDx69KjYxFxRb8f9rk917PxUrly5gtOnT8PLy0sa5A+8eWjpyZMnhV5BLYyDgwOWL1+Oe/fu4fz583IPpHxsH/kJxd27dwtcib5//77CMRYlPDwcL168kBKaj4m3pOsWt98UzQ2KkpaWhtu3b6Np06ZwdnaGs7MzcnNzsWjRIgQGBuLChQuwtraGuro6cnJyCvTx/PlzXL58udg+SuLzH6E+gUuXLmHHjh1wdnbGyJEj4eTkhO3bt0tjYLS0tNCqVSsEBQXJTUUghMCCBQvg5eWF3NxcqKiowMrKCufOncO9e/ekeqmpqdi4caN0ItTS0kJycrLcvfCoqKgCB878bL6oW0WqqqqwsLDAhQsXcOPGDbllv/76q/RU3cdITU2Fs7Mz1q5dK1duaGgI4P++kWlpaQH4v4Mh8OYy8JUrV+TWs7Gxwe3bt+WmBsh/cu7GjRuoWLGiQnVsbW1x69Yt/P7773Ltb9myBV5eXrhz5w7y8vLg5uaGBQsWyNUxMjKSYlekTkk9f/4cderUkUvm/vnnH5w9exZAwSsAb7++tra2ePHiBXbs2CHX5rFjx+Dp6Vnsz2116dIFqamp2LZtm1z5rl27kJqaWuL3gp2dHVJSUnDgwAGpLCcnp0Bsz58/R/Xq1eWSqOTkZGm9t8e+5LdR0nW9vLzg7e0tt6/09fWhpqYmtZv/DXnNmjVy8UVFRWHcuHFyj/irqKjIxbFw4UKMGTNG7mf2GjdujKpVq743EbO0tER2djbWr18PHR0daGlpQUlJCW3btkVwcDBu3br13n3/bjylae7cuahevToCAgLkjlPvMjQ0RJ06dbBnzx65KXOioqKwf/9+ZGRkoGPHjqhQoQI2btwoV+fx48c4fPgwjI2NoampCQsLC6irq2PLli1yt7R27Ngh95oaGRmhbt262LJli9xrkZWVBR8fH8yePfuDPpPvMjIyQu3atbFjxw65sXppaWnYsWMH6tSpI3f16nPKnxLk3aswmzdvRl5ensLTpPTu3Ru5ublYuHAhsrKy5G63fmwfhoaGaNiwIXbv3i1NkQQAp0+fljtnfojU1FQsWrQI6urqGDp0aInjffe4U9JtLW6/KZobFOXu3bsYNGiQNLVKfrz57z0VFRWoqKigS5cuCAkJwa1bt+TWDwgIwMSJE6XbxR/rX32F7vTp08WO8XJ0dERGRgZmzZqFWrVqYerUqQDezDJ++vRpzJo1CwcPHkSlSpUwa9YsuLm5oV+/fhgyZAhq1aqF06dP4/z585g+fbr07d/T0xPnz5/H4MGDMWTIEFSrVg379u1DWlqa9HNHXbt2RVBQEEaOHAlnZ2ckJiZi+/btaNasmTQxJgAp9o0bN8LCwqLQS7re3t64dOkSXF1d4erqioYNG+L3339HcHCwdOvnY2hqaqJv377Yvn07MjIyYGJiIo0Pq1WrlvRIto2NDVavXo3JkyfDzc0Nr1+/xtatW6Gjo4OYmBipvVGjRuG3337DmDFjMHToUNStWxfHjx9HbGyslDQqUsfDwwMnTpzAhAkTMHDgQMhkMty4cQN79+6FtbU1LC0toaSkBDc3NwQEBGDSpEno2LEj0tPTsWvXLlSuXBlOTk5QVVV9b52S6ty5M44ePYq5c+fC2NgYd+/exe7du9GgQQPcuXNHOlHlj0M5cuQIgDeTvTo5OeHAgQOYP38+rl+/DhMTE8THx2P79u3S/FdFcXZ2xqFDh7Bo0SLExMTAxMQEMTEx2LlzpzRvUUn07dsXe/fuxdy5c3H79m1oa2vjyJEjBebn69y5M9avXw9PT0907NgRiYmJ2L17N6pXr47Hjx9L21utWjVpQHKjRo1gZ2en8LojRoyAr68vRowYATs7OwghcODAAWRmZkq3SfJ/7mnDhg1ISEhAp06d8PTpU2zduhUNGzbEiBEjpJjzr57t2bMHHTt2xLBhwzBy5Ei4urrC0dERFSpUwKlTp5CQkPDenwfLn77k+vXrcoP+zc3NpQc13n1w5l2ampq4desWduzYgTZt2pTKmNt8tWvXxrRp0zB79mwbdl74AAAgAElEQVT4+flhw4YNhdZTVVXFjBkzMGXKFAwZMgS9e/eWJnfV1dWFk5MTNDQ04OXlhcWLF2Pw4MFwcHBAXl4etm3bhry8PMyaNQvAm4cNpk+fjnnz5sHd3R09evTA33//Lfezhvl9zp07F5MmTULfvn0xYMAAVKlSBQcPHkR0dDSWLVtWotunRalQoQJmzZoFb29vODk54euvv0blypWxZ88eJCUlfbJ+PgUTExNoaGjA398fDx8+hLq6Oi5evIiLFy+iXr16colvcerXr4+2bdvizJkzMDExkUtoPrYPZWVlzJ07F+PHj8fgwYPx9ddfIzExEVu3bi10TF9RwsLCpLk6MzMzkZiYKCVLP/74o3ThoCTx5ve/evVqtG3btsTbWtx+A6BwblAYQ0NDtGvXDsuXL8ejR4+gp6eHhw8fYuvWrWjatKl0RW7KlCkICwvDkCFDMGTIEHz11VeIiIjAb7/9BhcXF7nbuh/lkzwr+4kp+li4EEIsWrRIyGQycfDgQbk29uzZI2QymVi0aJFUduPGDTFmzBjRpk0bYWJiIvr161dgPSHeTHcwZswYYWZmJlq3bi1GjBghoqKi5Ors3LlT2NnZCSMjI9G7d29x6tQp8c0338hNW/Ly5UsxbNgwYWRkJHr16iW3bW+7d++emDp1qmjXrp0wNDQUffv2Ffv375erk/9Y+NuP8xdX/rbMzEyxatUqYW9vL1q2bCksLCzElClTCqxz8uRJ0adPH2FkZCS6desmdu/eLX755ZcC8T548EBMmTJFmJubCxMTEzF48GBx/vz5Etd5+vSpmDNnjrCwsBBGRkbCzs5OBAQEiIyMDKlOXl6eCAwMFA4ODsLExER06NBBjBkzRty6datEdQpT1L578eKFmDlzpujYsaNo2bKlGDhwoDh+/LiIiooqMH1I/hQnJiYm0jQAqampYvHixcLa2loYGhoKa2trsWDBAvHixYti4xFCiLS0NPHjjz9K69rY2Ihly5aJ9PR0uXqKTFsixJtH+efNmyfMzc1Fq1atxKRJk8SJEyfkphjIzMwUixYtEpaWlsLIyEg4OjqKXbt2iSdPngg9PT25z9DatWuFubm5aNmypYiMjCzRuocOHRJOTk7CzMxMtG3bVri5uYlLly7JxZuVlSV+/vlnYW9vLwwNDUXnzp2Fr6+vSExMlKsXFBQkOnXqJIyMjKTPcGhoqBg6dKgwNzcXZmZmwtnZudgpS942f/78AseR27dvC5lMJlxcXOTqFjZtSWhoqPSarVmzRggh5KbzeJsir13+caKoz3VeXp4YMmSIkMlkIigoqNi2Tp06JZycnISxsbHo1KmTmDFjhkhKSipQZ+DAgcLY2Fi0bt1aTJgwQcTExBRoKygoSPTo0UMYGhqK3r17i7CwMGFtbV1ge8LCwoSbm5swMTERZmZmYvDgwSIkJKTYOIUoetqSoqbNiIyMFO7u7sLExESYmJiIESNGFJgKqbD186fjeHeaDVtbWzFo0KBiY3zfaxMeHl7g/XH58mUxaNAgYWJiItq1ayemTZsm4uPjxTfffCMMDQ1FcnLye7dVCCF27dolZDKZCAwMLLDsU/QREhIi+vXrJ4yMjIStra04cuSIGDp0qMLTlrz9z8jISFhbW4vp06fLTRlT0ngfPHgg+vfvLwwNDcWoUaNKtK4i+00IxXKDoqYrS0lJEf7+/qJr167C2NhYWFtbCz8/P/Hs2TO5evHx8WLKlCmiffv2wtjYWPTq1UsEBgZK06d8CkpCvDWFNBERERGVO/+JMXREREREXzImdERERETlHBM6IiIionKOCR0RERFROceEjoiIiKic+3dM1FNC165d+ySzjRMRERGVtszMzCJ/Du9TKZcJXcWKFWFgYPC5wyAiIiJ6r+jo6FLvg7dciYiIiMo5JnRERERE5RwTOiIiIqJyjgkdERERUTnHhI6IiIionGNCR0RERFTOMaEjIiIiKueY0BERERGVc0zoiIiIiMo5JnRERERE5RwTOiIiIqJyjgkdERERUTnHhI6IiIionGNCR0RERFTOMaEjIiIiKueY0BERERGVc0zoiIiIiMo5JnRERERE5RwTOiIiIqJyTrWsO3RycoK6ujoAoFGjRvjf//6HWbNmITc3F02bNoWfnx9UVFTKOiwiIiKicqtME7qsrCzk5uZiy5YtUpmnpyc8PDzQqVMnzJkzB2fOnEG3bt3KMiwiIiKicq1Mb7nGxMQgPT0dw4cPx7Bhw3Dt2jVERUWhY8eOAAArKytcvny5LEMiIiIiKvfKNKGrWLEihg8fjg0bNmDevHnw9vZGdnY2lJSUAADq6up48eJFWYZERERE77FgwQLo6OhIf6ekpGDYsGGoXr066tWrh7lz5xa7/i+//AIdHR1UrlwZ3bt3x927d+WWL1myBI0bN0b16tXRt29fPHz4UFqWmJgIS0tLVKtWDR4eHhBCSMu8vb2xYsWKT7OR5VyZ3nJt3LgxGjduDCUlJTRp0gQ1a9bEzZs3IYSAkpISXr58iRo1ary3nczMTERHR5dBxERERF+22NhYfPvtt6hdu7Z07v3f//6Hx48fIzAwEC9fvsSkSZOgqqqKAQMGFFj/4sWLGDNmDHx8fGBpaYmdO3eic+fOOHDgAKpUqYJjx45h3rx5WLp0KZo2bYqlS5eiT58+0vAsf39/NGzYEDNmzICHhwdWr16Nrl274smTJ9izZw8OHTrEnABlnNAFBQXhxo0b+Pbbb5GUlITU1FTY2Njg0qVLMDc3R0hICGxsbN7bTsWKFWFgYFAGERMREX258vLyMHLkSHTu3Bl37tyBgYEBbty4gZCQENy+fRvNmjUDAMTHxyMuLq7Qc7OPjw+cnZ2xcOFCAICdnR309PRw7do1jBo1CqtWrYKdnR3Gjh0LAKhfvz5atmyJOnXqoFatWnjy5Am8vLxgZ2eHzp07Iy0tDQYGBli3bh2mTp0KExOTstshH6gsEs4yveXar18/pKenY/DgwfDy8oK/vz98fHywatUquLi4QE1NTaGEjoiIiEpfQEAANDQ0MHToUKnszJkzMDY2lpI5AJg9ezY2bNhQaBuxsbHo0KGD9LeysjJatmyJixcvAgDMzMwQFhaGmJgY5ObmYtu2bahYsSIqVaoE4M3dvStXriAzMxNRUVFo3LgxHj16hMOHD8PDw6M0NrtcKtMrdBUqVMD3339foDwwMLAswyAiIqL3uHv3LhYsWIDw8HCEhoZK5bGxsdDV1cXSpUvx888/Q0VFBaNGjYK3t7c0Jv5tdevWxYMHD+TKEhISkJ6eDgAYOXIkzp8/Dz09PaipqUFNTQ0rV65ElSpVAABTp06Fra0t/Pz8YGNjAycnJ3h7e2PSpElS0kecWJiIiIgK4eHhgWnTpqFp06Zy5ampqThz5gxOnz6NnTt3wt/fH4sWLUJAQECh7QwePBhr165FWFgY8vLysGHDBvz555/IysoCAPz666/Yu3cvAgMDERkZCVdXV8TGxkoPPzRr1gxxcXFITEzE8ePH8fjxYxw5cgQeHh7w8fGBtrY2xowZg9zc3NLdIf9yZT6xMBEREf27/frrr3j69Cm8vLwKLFNVVUVmZiZ27NiB6tWro3Xr1rh79y5Wr16NSZMmFag/cuRIxMTEwNraGkII2NnZwcXFRZrVYsmSJfDx8YGrqysAYPXq1TAwMEDLli3h4uIC4M1tWk1NTQBvHpLw9PTElStXEBwcjJiYGLi4uGD37t0YPHhwae2Sfz1eoSMiIiI5W7duxa1bt1C7dm3UqFED48ePR0JCAmrUqIGsrCzUr18f1atXl+obGBjg/v37hbalrKyM77//Hq9evUJSUhKOHDmClJQU6OrqAgDu3buHVq1aSfVVVFRgYmKCsLCwAm09ePAAR48ehYeHB8LDw9G1a1dUqlQJ3bp1Q0RExCfeC+ULEzoiIiKSs2PHDkRHR+PatWu4du0avv32WzRo0ADXrl1D//79ce/ePTx+/Fiqf+PGjQK3ZvMtX74cS5YsQYUKFVCzZk28fv0aJ0+elB6C1NXVxfXr1+XWuXXrFurXr1+grYULF8LLywsVK1aEsrKydFs2Ozsb2dnZn2rzyyUmdERERCSnXr160NHRkf7Vrl0bqqqq0NHRQffu3WFgYIChQ4fi5s2bOHXqFBYvXoyJEycCeDPVydOnT6UEq0mTJli4cCHOnDmD2NhYDBs2DHp6eujevTsAwMvLC0uWLMH+/fsRFxeHadOm4e7du3JP1gJvruQdP34co0ePBvDm6djffvsNf//9N/bt24e2bduW4R7692FCR0RERApTVVXF8ePHUa1aNbRt2xYuLi4YP368lGglJCRAS0sLFy5cAAA4Ojpi5syZcHV1RcuWLZGTk4PDhw9DWflNCjJixAj4+/tjxowZaNWqFSIiIhAcHCz3yxSA/NU54M3PhVpZWcHMzAy1atWSxtt9qZTE27+hUU5ER0dzYmEiIiIqF8oib+EVOiIiIqJyjgkdERERUTnHhI6IiIionGNCR0RERFTOMaEjIiIqI7k55e45RHrLv/n1409/ERERlREVVSXsXZf4ucOgD/S1R73PHUKReIWOiIiIqJxjQkdERERUzjGhIyIiIirnmNARERERlXNM6IiIiIjKOSZ0REREROUcEzoiIiKico4JHREREVE5x4SOiIiIqJxjQkdERERUzjGhIyIiIirnmNARERERlXNM6IiIiIjKOSZ0REREROUcEzoiIiKico4JHREREVE5x4SOiIiIqJxjQkdERERUzjGhIyIiIirnmNARERERlXNM6IiIiIjKOSZ0REREROUcEzoiIiKico4JHREREVE5x4SOiIiIqJxjQkdERERUzjGhIyIiIirnmNARERERlXNM6IiIiIjKuTJP6NLT09G1a1fExsbixYsXGDt2LFxdXTF58mSkpaWVdThERERE5V6ZJ3QrVqzAq1evAADr16+HjY0NtmzZAgMDA+zevbuswyEiIiIq98o0oYuKikJKSgr09PQAAJcvX4aVlRUAwMrKCpcvXy7LcIiIiIj+E1TLqqOcnBz8+OOPWLZsGSZPngwAePHiBapWrQoAUFdXx4sXLxRqKzMzE9HR0aUWKxERUWkwMDD43CHQR/q35h9lltD98ssvcHR0hKamplRWrVo1vH79Gurq6nj58iVq1KihUFsVK1bkh4KIiIjK3IfkH2WRBJZZQnfu3DkoKysjKCgI0dHR8PHxgUwmw/nz59GvXz+EhISgTZs2ZRUOERER0X+GQgndvXv3EBwcjLCwMDx48AApKSmoVq0a6tevj/bt26Nbt27Q0dEpto1t27ZJ/3d1dcW8efNQs2ZN+Pr6Yv/+/dDU1IS/v/9HbQwRERHRl0hJCCGKWhgTE4OAgAAEBwejZs2aMDExQd26dVG1alWkpaXh8ePHuHHjBh4+fIiuXbvC09MTurq6pR50dHQ0b7kSEVG5tHdd4ucOgT7Q1x71Pmi9sshbirxCFxAQgO3bt6NXr17Yv38/9PX1i2wkNjYW+/fvx9ChQzF06FD873//K5VgiYiIiKigIhO61NRUHDt2TKEHFXR1dTFt2jSMGjUKa9as+aQBEhEREVHxikzoZsyYUeLGatas+UHrEREREdGH+6CnXOPi4hAeHo7MzEy0bdsWRkZGnzouIiIiIlJQiX8p4sSJE+jXrx+CgoJw4MABODs7yz3BSkRERERlq8grdDk5OVBVLbh43bp1WLNmDTp06AAA2LVrF1auXAkXF5fSi5KIiIiIilTkFTp7e3scPHiwQHlubi7enulERUUFSkpKpRMdEREREb1XkVfovvvuO6xYsQLr16/H5MmT0a1bNwCAu7s7PDw8oK+vj7y8PNy+fRvTpk0rs4CJiIiISF6RCV2HDh3QoUMHnD17FitXrsSaNWswZcoU9O3bF0ZGRggLC4OSkhJMTU35UAQRERHRZ/Tep1ytra1hbW2No0ePYsGCBdDU1MSUKVPg5uZWFvERERER0XsUm9A9f/4c169fR3Z2Nlq1aoUjR47gwIEDmDZtGnR1deHl5cWf4CIiIiL6zIpM6E6fPo1p06ZBTU0NqqqqePnyJSZPnozRo0ejT58+2LVrF8aMGQNTU1N4enqiSZMmZRk3EREREf1/RT7lumjRIowfPx6RkZEICwvDTz/9hGXLliE5ORmqqqpwcXHBqVOn0LJlS7i6upZlzERERET0liITuvT0dNSqVUv6u379+sjLy0NWVpZUVrFiRYwcORInTpwo3SiJiIiIqEhF3nIdNWoUZs+ejcDAQFSqVAm3bt2Co6Mj6tatW6BulSpVSjVIIiIiIipakQnd8OHD0aFDB0RGRiIvLw9eXl5o165dWcZGRERERAoo9ilXfX196Ovrl1UsRERERPQBihxDFxAQgPT09BI1lp6ejlWrVn10UERERESkuCITupcvX8LOzg7r1q3D48ePi23k4cOHWLVqFezt7fHy5ctPHiQRERERFa3IW66zZs1Cz549sWzZMqxYsQJ6enowMjJCnTp1UKVKFbx69QpJSUm4evUq7t69C3NzcyxfvhxmZmZlGT8RERHRF6/YMXSmpqYIDAxEVFQUTp06hbCwMAQHByMlJQU1atRAw4YN0a1bN9jZ2cHQ0LCsYiYiIiKit7z3t1wBoGXLlmjZsiW8vb1LOx4iIiIiKqEix9ARERERUfnAhI6IiIionGNCR0RERFTOMaEjIiIiKueY0BERERGVcwo95QoAr169QmBgIC5duoQnT55g+fLlCA0NhUwmQ+fOnUszRiIiIiIqhkJX6B48eAAHBwcEBQWhTp06iIuLQ1ZWFu7fv4+xY8ciJCSktOMkIiIioiIodIXO398furq6WLNmDZSUlHDo0CEAgJ+fHzIyMvDTTz/BysqqVAMlIiIiosIpdIUuLCwMw4YNg5qaGpSUlOSW9enTBzExMaUSHBERERG9n0IJnZqaGpKTkwtdlpycjAoVKnzSoIiIiIhIcQoldBYWFli6dCmio6OlMiUlJbx48QLr1q3jQxFEREREn5FCCZ2vry+qVKkCJycn9OnTBwAwZ84c2NnZ4fXr15g+fXqpBklERERERVPooQgtLS0cOHAAQUFBiIyMRN26daGhoYG+ffuif//+qFKlSmnHSURERERFUCihu3TpElq0aIGBAwdi4MCBcstSUlJw9OhR9OzZs1QCJCIiIqLiKXTL1c3NDbGxsYUuu3nzJnx9fT9pUERERESkuCKv0E2aNAn37t0DAAghMH36dFSuXFmujhACDx8+RIMGDUo3SiIiIiIqUpEJnZubG/bt2wcAiI6ORuPGjaGpqSlXR0lJCe3bt0f//v1LN0oiIiIiKlKRCV2bNm3Qpk0b6e/x48fjq6++KpOgiIiIiEhxCv/0FwDk5OQgIyNDKs/Ly0N6ejouX76MXr16lU6ERERERFQshRK6mJgYeHt7486dO0XWUSShy8vLw9y5cxEbGwslJSX4+fmhSpUqmDVrFnJzc9G0aVP4+flBRUVF8S0gIiIi+sIplNAtXLgQycnJ8PHxQUhICFRUVNCxY0eEhIQgJiYG27ZtU6izM2fOIDc3Fzt27EB4eDiWLVuGSpUqwcPDA506dcKcOXNw5swZdOvW7aM2ioiIiOhLotC0JTdu3MCMGTPg7u6Onj17Ij09HSNGjMDmzZvRtm1bHDp0SKHObG1tMX/+fADAgwcPYGxsjKioKHTs2BEAYGVlhcuXL3/gphARERF9mRS6QpeTk4O6desCAJo0aSL3m679+/fHN998A09PT8U6VFXFjBkzcPLkSUyZMgXZ2dlQUlICAKirq+PFixfvbSMzM1MuBiIiovLAwMDgc4dAH+nfmn8olNBpa2vj1q1baNOmDZo1a4a0tDTExcWhadOmUFJSUigJe5u/vz+8vb3Rr18/ZGRkQAgBJSUlvHz5EjVq1Hjv+hUrVuSHgoiIiMrch+QfZZEEKnTLdeDAgfj++++xbt061KhRAyYmJpg3bx4OHz6MFStWQF9fX6HODhw4gHXr1gEAKlWqhCpVqqB9+/a4dOkSACAkJERuqhQiIiIiej+FrtANGTIEeXl5iI+PBwDMmzcPEyZMwLRp01C/fn2sXr1aoc7s7Ozg4+MDFxcXCCEwa9Ys6OjoSE+56urqwsbG5sO3hoiIiOgLpCSEEO+rFBUVBX19fVSoUEGuPDk5GTVr1iy14IoSHR3NW65ERFQu7V2X+LlDoA/0tUe9D1qvLPIWhW65jhs3DsePHy9Q/jmSOSIiIiKSp1BCp6qqKj2JSkRERET/LgqNoRs5ciS+++473Lx5E/r6+tDQ0ChQp2vXrp88OCIiIiJ6P4V/KQIANm7cWOhyJSWlf+28LERERET/dQoldMHBwaUdBxERERF9IIUSuoYNG5Z2HERERET0gRR6KIKIiIiI/r2Y0BGVc/Hx8ejXrx9q1qyJr776Cj4+PsjKyipQz87ODu7u7kW2I4SAhoYGlJSU5P6lpqYWqGdra4tffvlFrjwoKAgNGjTAV199hcOHD0vlGRkZaN68ORITOfcWEVFpYUJHVI5lZ2fDwcEBKioqiIiIwPbt27F37174+fnJ1duwYQNOnTpVbFvx8fFIS0vD/fv38eTJE+nf20+15+XlwdPTs8C42tzcXHh4eGDr1q1YvHgxhg8fjry8PADAunXr0Lt3b9Sr92ETchIR0fspNIaOiP6dIiMjcfPmTVy4cAFVq1aFTCbD/PnzMX36dPj7+wMAHj16hFmzZqFjx47FtnXz5k00atSoyDGzDx48gKurK+7evYsaNWrILXv69CnU1NRgY2ODrKwsuLi44OnTp6hWrRpWrlyJ8+fPf5oNJiKiQil8hS4hIQF///03AODZs2eYO3cuJkyYIHdrhYjKlkwmw5EjR1C1alWpTElJCa9fv5b+Hj9+PCZOnIjmzZsX29bNmzeLrfPHH39AW1sbkZGRqF69utyy2rVrIyMjAwkJCYiMjISGhgZq1aqFNWvWoE+fPrw6R0RUyhRK6EJCQtC7d2/s378fADBjxgwcOHAAL168gK+vL/bs2VOqQRJR4bS0tNC9e3fpbyEEVq9eLU30vXv3bsTGxmLatGnvbevmzZvIyspC9+7d8dVXX6Fv376IjY2Vljs4OGDTpk3Q0tIqsK6KigoWLFgAmUwGW1tbLF++HFlZWVi5ciV8fHw+wZYSEVFxFEroAgIC0LNnT0ydOhVJSUk4d+4cPD09sXXrVkycOBGbNm0q5TCJSBHjx4/HlStX8M033+DZs2fw9PTEunXroKam9t51o6Oj8fTpU0yZMgUHDx6EmpoarK2t8fLlS4X6HjduHJ4/f47k5GSMHDkSP//8M/r164fc3FxYWlqiWbNmOHDgwMduIhERFUKhhC42Nhb9+/eHiooKfv/9dwBvnpgDADMzMzx48KDUAiQixUyePBnr1q3D5s2bYWhoCE9PTzg5OaF9+/YKrR8aGoqrV6/Czs4OZmZm2Lp1KzIyMkqUhKmrq6Ny5cpIS0vDqlWrMH36dPj5+aFv374IDQ3FxIkTkZaW9qGbSERERVDooYgqVaogOTkZAHDmzBloa2ujUaNGAIC7d+9CU1Oz9CIkomLl5eXBw8MDmzdvRmBgIJydnQEAW7duhYaGBrZs2QIAUiL1xx9/ICoqqkA7ampqclfyKlasCB0dHTx8+LDEMf3000/o168f6tati/DwcEyZMgUNGjRAw4YNERMTAxMTkw/ZVCIiKoJCCV3Xrl3xww8/IDIyEufOncOkSZMAvJkKYc2aNejbt2+pBklERZs6dSq2bNmCffv2oU+fPlL53bt3C9QDgOXLlxdoIy8vD9ra2vD394erqysA4PXr14iJiYGBgUGJ4nn9+jVWr16N8PBwAICysjKEEADeTLOSnZ1dovaIiOj9FLrl6uPjg/bt2yMyMhJDhgzByJEjAQD79u1D165dMWXKlFINkogKd+nSJSxbtgzz589Hx44d8fTpU+mfjo6O3D8NDQ1oaGhIV9ezs7Px9OlT5OXlQVlZGb169cLcuXNx/vx53L59G+7u7tDW1kavXr1KFNPq1avh5OSEunXrAngzLGPLli24ePEi4uLi0KJFi0++H0hxxU1EHRoaivbt20NDQwP6+voIDAwstq0LFy6gTZs2qFy5MkxMTBAaGiotS0xMhKWlJapVqwYPDw8pqQcAb29vrFixonQ2kOgLpdAVOnV1dcyfP79A+eHDh6GszLmJiT6X3bt3A3jzpevdp0nfPoEW5sKFC7C2tsbdu3eho6OD5cuXY+bMmRgwYABevnwJGxsbHDlyBKqqik9XmZqaip9++gmRkZFSmZ+fH/r374+1a9di+fLlqFKlSgm2kD6l/ImoZTIZIiIikJSUBHd3dygrK2P06NHo0aMHZs2ahZ07d+LixYsYPnw46tatC3t7+wJtxcfHo0ePHpgwYQL27duHTZs2wdHRETExMdDS0sKiRYtgZGSEX375Bd27d8ehQ4fg6OiIxMREHDx4EH/99ddn2ANE/11K4n1H/f8vISEBmZmZaN68OZ49e4YVK1bg+fPnsLe3h4ODQ2nHKSc6OrrEt4GIiL50Fy5cgJWVFZKTk6W5C7dv347p06dj3LhxOHjwoFwy7uHhgbS0NGzdurVAW9OmTUNERIR0VU4IATMzMyxYsAA9e/ZEjx494OXlBTs7OwwZMgQmJiaYPn06vLy80KRJE2nozpdo7zr+DF559bXHh82pWRZ5C+ehIyL6QhQ3EfWAAQOwatUqufrvTlL9tjNnzqB///5yda9evYqePXsCABo3bowrV64gMzMTUVFRaNy4MR49eoTDhw/Dw8OjFLaO6MvGeeiIiL4QxU1ELZPJYG5uLi1LSkrC7t27pUmq3xUbG4uqVati4MCBaNCgAaysrHDp0iVp+dSpU7F27VpUrVoVjRo1gpRMoLcAACAASURBVJOTExYtWoRJkyahUqVKpbeRRF8ozkNHRPSFensi6re9fPkSffr0gZaWlvQQ3LtSU1Ph4+ODdu3a4cSJE2jXrh1sbGykaW6aNWuGuLg4JCYm4vjx43j8+DGOHDkCDw8P+Pj4QFtbG2PGjEFubm6pbyfRl0ChhI7z0BER/be8OxF1vlevXqFHjx6Ii4vDoUOHULly5ULXV1VVhb29PaZMmQJjY2MsWbIETZo0webNm6U6ysrK0vnB398fnp6euHLlCoKDgxETE4OnT59KD/YQ0cdRKKHLn4du/vz5OHfuHPr16wfgzTx0P/74I2xtbUs1SKKylpOT9blDoI/A169oeXl5GDVqFH766Se5iagB4Pnz57C2tkZsbCyCg4Ohr69fZDv16tUrsNzAwAD3798vUPfBgwc4evQoPDw8EB4ejq5du6JSpUro1q0bIiIiPt3GEX3BFJqPwMfHB/7+/pyHjr4YqqoV8ONP1p87DPpA3uPPfu4Q/rWKmog6KysLvXr1QlJSEs6fP49mzZoV20779u1x5coVubKbN2/C3d29QN2FCxfCy8sLFStW5ETTRKWE89AREX0h8ieiXrx4sTQRdb6NGzfi8uXLOH36NGrUqCEtU1NTQ/Xq1ZGdnY2UlBRoampCWVkZkydPhqWlJZYuXYq+ffti06ZNSEhIgJubm1yf9+7dw/Hjx7F06VIAb8Zdjx8/HqNHj8a+ffsKTQCJqOQUzsZycnJw4MABzJo1C6NHj0Z8fDwOHTqE27dvl2Z8RET0ibw9EbWWlpbcv927dyMnJwddunSRK3d0dATwZg47LS0tJCQkAAA6dOiAgwcPYuPGjdDX18fBgwdx+PBhaGlpyfX59tU5ALCysoKVlRXMzMxQq1YtuLi4lOEeIPrvUmhi4RcvXmDEiBH/r707j4/p+h8//prssstiDRFLLNkjsROJrZT+KiV87aS119qilrYoqvhYQ8ValFLUUkVtpfalVTshSCQikUU2ss39/ZFPhmmClKyfvp+PRx4Pc8+5554zc915zznnnktYWBh16tThwoULbN26lVWrVnHkyBHWrFlTpA/bloWFRVGQIdfSS4ZcRUkmCwuXXqV+YeHZs2ejUqk4ePAga9eu1cx/mDt3Lg0bNmT+/PmFWkkhhBBCCPFy+QroDh06xJAhQ7C0tESlUj3fWUeHnj17cvXq1UKroBBCCCGEeLV8BXSZmZmo1eo809LS0gq0QkIIIYQQ4p/JV0Dn7e3NwoULiY6O1mxTqVRkZGSwbt06vL29C62CQgghhBDi1fK1bMmECRPo2bMn7dq1w9vbG5VKxeLFiwkNDeXJkyds3LixsOsphBAlUnpmJgZ6+bqUihJIPj/xvyJfZ7GDgwM///wza9eu5ezZs1StWpXo6Gh8fX3p378/5cuXL+x6CiFEiWSgp0fbNd8WdzXEG/q1/+DiroIQBSLfP0usrKwIDAzUPBUiMTGRhIQECeaEEEIIIYpZvubQJSYmEhgYSLdu3TTb/vzzT9q2bcvHH39MampqoVVQCCGEEEK8Wr4Cujlz5nDnzh0+/fRTzbbGjRsTHBzMtWvXWLBgQaFVUAghhBBCvFq+ArrDhw8zYcIEWrVqpdlmYGBAixYtGDt2LL/88kuhVVAIIYQQQrxavgK61NRU9PX180wzMjIiJSWlQCslnktPT6devXocPHhQs+3MmTM0btwYU1NTnJ2d2bNnzyvL+Prrr6lSpQqWlpYEBARoLT8TFRVFixYtMDc3Z+DAgbz4JLixY8eycOHCgm+UEEIIIQpUvgI6Dw8P1qxZw7Nnz7S2P3v2jDVr1uDm5lYolfu3S0tLo2fPnly/fl2zLSUlhY4dO9KgQQOuXr3Kp59+SteuXbXyvGjlypXMmzePtWvX8scff6Cvr681F/Lrr7/G2dmZ8+fPc/DgQXbt2gVkB3o7d+5k0KBBhdtIIYQQQry1fN3lOm7cOHr37o2Pjw+NGjXC2tqa2NhYTp8+jVqtZt26dYVdz3+da9eu0bNnzzy3P378mKlTp2JpaUnfvn1ZtGgRv/zyS54P/k1OTmbWrFma4fJx48bh7u5ObGws1tbW3Lx5k9GjR+Po6EijRo24efMmkP383hEjRmBkZFS4DRVCCCHEW8tXD12dOnXYsWMH77//PlFRUZw8eZKEhAS6devG/v378wwkxNs5duwYvr6+HD9+XGt7zZo1MTc357vvvkNRFM6ePcuNGzewsLDIs5xRo0bx4YcfAtlD50uWLMHQ0FATqNnb23PhwgXS0tK4dOkS9vb2PHz4kN27dzNw4MDCbaQQQgghCkS+16GrXLkyQ4cO1QQOOevQWVlZ5ftgmZmZTJ48mbCwMNLT0xk6dCiOjo5MmjSJrKwsqlevzhdffIGuru4/b8n/mMGD817ssmzZsmzevJnOnTszbtw40tPT6dSpU569eS9asWIFQ4cORUdHh4ULF2JiYgLAJ598QuvWrfniiy/w8/Pjgw8+YOzYsdI7J4QQQpQiRboO3e7duzE2Nmbjxo0EBwczffp05s6dy8CBA9mwYQOKonD48OE3a8m/xMOHD+nbty+9e/fm7NmzrFq1imfPnhETE/PK/d555x3++OMPPv74Y06ePElmZiaQ3eMXGhpKVFQU+/btIzo6mp9//pmBAwcyfvx4qlatyqBBg8jKyiqK5gkhhBDiDRTpOnRt27Zl9OjR2QfWyT70pUuXaNKkCQA+Pj6cP3/+HzXg32bt2rVYWFjw7bff4ubmxoABA2jevDmBgYGv3K9KlSq4uLgwd+5cLl68yPr16zVpOjo6mp7WWbNmMWrUKC5cuMChQ4e4desWjx8/ZsuWLYXaLiGEEEK8uXwNuR4+fJgpU6a8dB26mTNnMnHixNeWkzPMl5yczIgRIxg5ciTz5s1DpVIBYGxsTEJCwmvLSUtLe+ldnf+r7t+/z/Xr17l06RLVqlXT3LwAYGtry4kTJ/J8T06ePImdnR1Vq1bVbKtUqRIHDhygUaNGWnkfPXrEzp072b17N99//z3u7u7cvXsXZ2dn9u7di7u7e+E1sISReaGlX1FdI+RcKf2K8vtEzpfSr6TGH/kK6ApyHbpHjx4xfPhwAgICeP/991m0aBGKoqBSqUhMTMTS0vK1ZRgaGv7r/lPY29tTt25dvLy8WLFiBXXq1NEEwr/88guVKlXK8z0ZPHgwXl5ezJs3D4CsrCxCQ0Px8/PLlX/JkiWMGzcONzc3zdB33bp1sbGx4fHjx/+691yUbnK+ivySc0X8E29yvhRFEFik69BFR0czYMAARo8eTdeuXQFwdnbm3LlzABw9ehQvL69/Uv9/nb59+xITE8OoUaO4c+cOu3btYubMmQwdOhQAtVrN48ePycjIAGDEiBEsX76cHTt2cPv2bYYOHUp8fDx9+vTRKjc8PJx9+/bx0UcfAeDp6cmePXsICQlh27ZteHt7F21DhRBCCJFvRboOXXBwMAkJCSxbtoxly5YB8PnnnzN9+nSysrKoUaMGfn5+b96afwEbGxt+++03Ro4ciYeHB+XKlWPSpEmMGjUKgLCwMBwcHDhy5AgtW7bkgw8+IC4ujk8++YSYmBgaNWrE0aNHqVChgla5M2fOZPTo0RgaGgLZ8xl9fHzw9PSkbdu2r72LVgghhBDFR6W8+KynV4iMjOS7777j4sWLPHnyhPLly+Pm5ka/fv3+0dIlBeH69evSRS4K3bylvsVdBfGGxg49UqTHa7vm2yI9nig4v/bPe4mowrQ1OKrIjykKRpeBFV6fKQ9FEbfkex26SpUq8dlnnxVmXYQQQgghxBvIV0C3Y8eO1+Z5//3337oyQgghhBDin8tXQDdhwoQ8t6tUKoyMjDAxMZGATgghhBCimOQroMu5C/VFKSkpXLhwgfnz52uWxCjJlMxMVHr5HmEWJYx8fkIIIcTL5esb0szMLM9t7777Lk+ePGHatGls27atwCtXkFR6ejyctqS4qyHeUMXPhxd3FYQQQogSK1/r0L1KtWrVuH37dkHURQghhBBCvIF89dAlJyfn2paVlcXjx49Zvnw59vb2BV4xIYQQQgiRP/kK6Ly8vDSPmfo7AwMDFi1aVKCVEkIIIYQQ+ZevgG7mzJm5AjqVSoWFhQWurq5YW1sXSuWEEEIIIcTr5Sug8/f3L+x6CCGEEEKIN/TKgE6tVnPixAkqVapEjRo1AHjw4AFBQUHcvXsXBwcHhgwZQtWqVYukskIIIYQQIreX3uWamppK9+7dGThwIL/++isAT548oWfPnvz8889YWFhw+fJlAgICiI6OLrIKCyGEEEIIbS8N6NavX09oaChz5syhT58+AGzYsIFHjx4xceJEli9fzo4dO6hVqxZBQUFFVmEhhBBCCKHtpQHdzz//zKBBg+jYsSMmJiYA7N+/HzMzM7p06QKAnp4e3bt35/Tp00VTWyGEEEIIkctLA7qIiAhcXFw0r+Pj4wkJCaFhw4bo6+trtpcrV47IyMjCraUQQgghhHiplwZ0xsbGpKWlaV6fOnUKRVHw9vbWyhcVFYWxsXHh1VAIIYQQQrzSSwO6OnXqcPDgQc3rXbt2oaOjg5+fn1a+n376CScnp8KroRBCCCGEeKWXLlsyePBg+vTpQ2xsLGq1mt9++42OHTtSpUoVAC5evMiGDRs4deqUPClCCCGEEKIYvbSHzsvLi6CgIBITE4mMjKR///7MmDFDkz548GD27dvHiBEjaNOmTZFUVgghhBBC5PbKhYV9fX3x9fXNMy0oKAgHBwesrKwKpWJCCCGEECJ/8vXor7zUr1+/IOshhBBCCCHe0EuHXIUQQgghROkgAZ0QQgghRCknAZ0QQgghRCknAZ0QQgghRCknAZ0QQgghRCknAZ0QQgghRCknAZ0QQgghRCknAZ0QQgghRCknAZ0QQgghRCknAZ0QQgghRCknAZ0QQgghRCknAZ0QQgghRCknAZ0QQgghRCknAZ0QQgghRCknAZ0QQgghRCknAZ0QQgghRCknAZ0QQgghRCknAZ0QQgghRCknAZ0QQgghRCknAZ0QQgghRClX5AHduXPn6NmzJwAJCQkMHjyY3r17M3LkSFJTU4u6OkIIIYQQpV6RBnTBwcFMmzaNjIwMAFasWIGfnx/r16+nbt26bNmypSirI4QQQgjxP6FIAzp7e3sWL16seX3+/Hl8fHwA8PHx4fz580VZHSGEEEKI/wl6RXmwdu3a8eDBA83rhIQEzMzMADA2NiYhISFf5aSlpXH9+vV/dOy6dev+o/yi5Pmnn/nbkPOl9Cuq80XOldJPri3inyjK8+WfKNKA7u/Mzc1JSUnB2NiYxMRELC0t87WfoaGh/Kf4F5LPXPwTcr6I/JJzRfwTb3K+FEUQWKx3uXp5eXH8+HEAjh49ipeXV3FWRwghhBCiVCrWgO6jjz5i79699O7dm5CQEAICAoqzOkIIIYQQpVKRD7na2dlp7ma1srIiODi4qKsghBBCCPE/RRYWFkIIIYQo5SSgE0IIIYQo5SSgE0IIIYQo5SSgE0IIIYQo5SSgE0IIIYQo5SSgE0IIIYQo5SSgE0IIIYQo5SSgE0IIIYQo5SSgE0IIIYQo5SSgE0IIIYQo5SSgE0IIIYQo5SSgE0IIIYQo5SSgE0IIIYQo5SSgE0IIIYQo5SSgE0IIIYQo5SSgE0IIIYQo5SSgE0IIIYQo5SSgE0IIIYQo5SSgE0IIIYQo5SSgE0IIIYQo5SSgE0IIIYQo5SSgE0IIIYQo5SSgE0IIIYQo5SSgE0IIIYQo5SSgE0IIIYQo5SSgE0IIIYQo5SSgE0IIIYQo5fSKuwLi5WJTkui2Log9H43FUE8fgPTMTNot/4Z367nziW8HABRFodbMT0hNT9faP2TiXEwMDbW2bb90juHb1hE5dfELx0nm012b+O3OdayNTRnt054e9RsDMGjLav7PszEta9YtzKaKApCclE7w4r8Y8Wl9/jj3iMO/hpGUmE616uZ07uaIjW0ZANRqhcP773Pm5EOepmZStZo5nbvVwracMQBPEtL4aUsIt2/GU8ZYj2Yt7fBpVUVznOioFLb+cIuwu4lYljWiXcdqeHiVB2D39jvY2JahcfNKRf8GiHxLT0ziwrxFNJw8Dh397GuLOjOT01NnUr6+JzXe75hrn9Bdv5AS9QiXgf0BiLtxiwvfzM+zfK/xY4i7fpPQXXtyJ6pUtFm1lEtLV1CpRVNsnOsVXMNEoXiS9JjpC7oza8Ie/rh8kB/3/IeomHtUsHWgZ+eJeDj7AZCVlcmG7V/x+9ntqLMyaej5Ln26fEkZIxMA4hKiWLVpIpdvHMfUxIL2voF0ajNYc5yd+5eyYft0rWN3ajOYPl2+4D/BA/Fr+n+4O/kWXcNLGQnoSrAZB3bRx6uZJpgDWHBsPzejH/JuPXfNtgcJcTzNyODC2OkY6D7/SP8ezD1OTmLK3m25jjN6xwbUisLhoZ9x+eEDPt62jho2tjS0r8nYlu3pv2kFvw2fhL6ubiG0UhSUX3aG0qh5JUJvJ7B9Swg9+tbFrqoZJ44+YNXSS4yd5I2eng6/HQzj5O+RdO9TByvrMhzcd5+VQZf4ZJI3+ga6rF91lTLG+owcX5/kxHS+X3sdYxN9vBtVIDNDzapll7EtZ8zoz7x4HP2UH9bdwMBQFycXG/zaVuE/sy7g6mGLian+6ystikXI1h3YtWyuCeYAQnfvJSXiIdTPnT/q7AVCd+2hfAMvzTbLmjXwWThHK9+N9ZtIjXmMRc3qmFezp0qrlpo0dWYm52fNxcbdFYDq/68jFxcvo8lXX6CjJ9eWkuz7n2bStkVvQsMuMX/lED7q8TUudZpz4dKvfLOsP99M+pUqlWqzZfdczl/6lfFD12JcxoxVmyax+odJDOu3AID/BA/E1NiS2RP3kZAUw8KVQzEztaJl4wAAwh/e5N1WH+HfYaTm2IYG2T9Eu3YcyzfL+jP/y6Po6cq1JS8y5FpCPUiIY//NywS4N9RsuxYVwQ9/nKJuee3ej1sxUVQ0t6SiuSXWJqaav7+b9MuPOFWorLUtLP4xB29dZea7XalmZUsnJw86u3qx7twJABzLVaS8mQW7r/5ZCK0UBSUu9hlXLj3Gu1EFkpMzaNPeHlcPW6ysjWjdvhox0U+JikwB4OzJKFq9Y49jHStsbMvQtYcjSYnp3A19QlpaFpZlDekcUBPbcsY41LTExd2WyxdjALh+NZbExHR69KtL+QomOLna0KKVHUd+DQPAxNSAmrUtOX08stjeC/FqTx/HEnPxLyo1a6zZlhT+gMjfT2Bqp319UGdlcX3dRq6uXkcZWxutNB09XQzMTDV/yRGRxFy8hPOHfdHR1UXX0EArPeLYcVS6utT64H0ATCtXxNDSkkfnLxR+o8Ubi4kN5/zFfbRs0o0jJ3+ggfs7tGrWg3I2VWjvF0i9Wo04fvYnABRFTZ8uX1DLwZPKFWrR3ncAZ/7M7qV9lpaKddlKDOg+g4rlq1O3ZkMaeb7L6T+e9+I+eHiLqpXrYm5qrfkzNMgeOahSqTZlLcpz6sLuon8TSgkJ6EqojRdO0qpWPYz++ws6S61m7M6NTG77PpZljLXy3oqJorqV7SvL23fjErdiohjatLXW9gsP7lHezJyqZZ9frL2rVOfPiHua1++71GfD+RNv2SJRmM6efEhdJ2v09XXx9C5Pq3b2AGRmqjl2OBwAI6PsXhD/7rVwcXv+eatUKhQF0tPUGBrq0muAE1bW2b+Ko6NSuHrpMUZG2T2/j2OeUq68McYmz38hV7IzJTwsiawsNQAe9ctxSgK6Eivi2AlsXJzR/e+1RVGrubZmA7UC/NE30b62ZKWlkRz5kAYTP8GiZvVXlnvz+81Uat4E08q5h9ufxSdwd89+anR+D11DA832Cg29ePDb8QJolSgsh45vxMOlFQb6RrzTcgAfvDtaK12lUpGWngpAj84T8XZrB0BySgIHj3+PcRlzAIwMjRn90beUs8mevhERFcK5v/ZjXMZMU1Zk1G0qlnN4aV2aeb/PgWPrC7R9/0skoCuhDoVco0HVGprX3548jJWxCf6uXrny3oqJIj0rkx7rl1J/3hT6bwrmXlyMJj3x2VMm7fmRbzp11xqSBXj4JIHyZhZa2yqYm/MwMUHzukHV6pwPDyXp2dOCap4oYNevxuJQQ/tzvHktjkljf+fg3vu0eqcqNv+dI+dYxwpzi+fD8WdPPgSgWnVzrf2Xzv+Tb6afQ6WCNh2yA0QzcwOSEtNRqxVNvoS4NLIyFVJTM/9bjgVPEtJ4FJVS8A0Vb+3x5StY1np+bbm//yD6piZUbNQgV159Y2O8J4zFrGqVXGkvir16nZSHUVR7p02e6Q+OHKWMtRXlvTy0tpetVYMnd+6Q+VSuLSXVH1cOUadG9rlRrYoT9pWfz6cOj7zJlZsncanTXGufH3bOJvATZ66HnCaw+4xcZX4+tzOjvmiBChVd3x0DQEzcA54+S+bEuZ18PKUJY6b68svhlSjK82tNnZoNuXXnPKlPkwqjqaWeBHQlkFqt5tqjCGrZZk80D42NZtmJQ3zdsVue+W/HRBGXmsLAxr6s+b+B6Ovo0mXtYk0ANnX/T7St7YJ31dy/sNMyM3MFeQa6eqRlZmr+IznaVgDgStSDAmujKDhqtcLDiGTKVdDuXalkZ8qo8fVp/151IsKSefYsM9e+t2/Fs3PrbXxaVcHUzEArrXNALYaNdqeslRER4ckA1KlnRXp6Fvt/vktWlpqY6FSO/5Z9XmRlZvfQGZXRo6yVEWH35KJb0ihqNcnhEZhUyv4/nfIomnt7D1C3T4+3Kjf80G/YerrnGpYFUGdk8ODocaq29kWlo/2VY1KpIgCJYeFvdXxRONRqNfcfXMOuYq1cabHxD5m9tB+ODp54umiP/LRs0o2vJ+6jgUcHbtw5l2vfwP+bybRPd2BrXYXQsMsARDwMAcDUxJKxA1fQ+Z3hbNk9l58PLtfsZ1fREYC74ZcLrI3/S+SmiBIo/mkKWWo1lmVMUBSFT3ZuYniz1lQpa51n/u0DRpGlVmuGZxd/0Aev/3zOvhuXqGBuyW+3r/PbsIl57muolx28vSgjKwtDPT1UKhUAOjo6WJQx5lFSYgG2UhSU1JQM1GowNtaeKGxmboCZuQEVK5ly984Tjh4Mp13H58MZobcTWL3sMo51y9L23Wq5yq1YOXseZsfONVi24CJ1nKwwNTOg74fO/LD+BkcOhGNuYUALPzt2bbuDodELN+SY6pOUmFY4DRZvLCM5BUWtRt8k+9pybc0GqnVoRxmbvK8t+ZH57BmPL1/F+cO+eabH3QwhIzkFW0/3XGkqHR30jI1JT3jyxscXhScpJQ61OgtTk7Ja2+OfPGLq/K4AjBm0QvNdkaOCbTUABvaczeAJ9fFw9sO5dlNNek4vX68PJvPlvA/wdGmFu5Mv3y24pRmCrVbFiYTEGPb9tkZzJ6yOjg4mJhYkPIkulPaWdhLQlWBqRSHiSTyn79/matQDFhzbD0BKehp/PLjHpcgw1vUcjL6urtYdqIZ6+lSxtCIq6Qkn7oYQm5KM9/wvAMhUZwFQZ9Y4vusxiArmlkQna19Mo5KeUMHMUmubzt/+w4qSJ6dH9V7oEwwMdKlk9/zGmPIVjAkPe95jduNqLN+tuErtelb0GlAPHZ3szzc1JYNbN+Jxr19Ok7dcBWPS0rKIfpRKVXtzatUpy5QZjUlOSsfYRJ/rV2IxNtGjTJnnlxM5XUo2RVF4FhtHwq0QksPDubv7FyB7ztyTO3dJvHcfj1HD8lVW/I1bAFi7OOeZHnvlGubV7DEqa5lnukolA0UlnVpRa/4d/TicqfO7oKurz5djtmJpnj1/W61Wc+HSr9SqXl+zzUDfiHI2Vblz7y/s7epx+frvNPF6T1OWXcVaPEtLISLqNjWruWvNpwOoXKEW8X8L3uR8eTkJ6EqgsmVM0NPRIT41hVo25Tkz6kut9CFb1+JpV43hzdqgVqvxnv8Fn7XuRBe37HkOqelphMbGUMu2Aj08mzC2ZXvNvhce3GPo1rUcGDweW1NzypuZ8ygpkftxj7G3yh4uORcWiqddNc0+iqLw5OlTbPK4c1YUP2MTfXR0VKSkZABw6ngk6WlZ9P3o+RdseFgS5cpnD8mG3Utk7YqruLrb0L1PXU0wB/D0aSYbVl+jfAVjTQ9d+P3sQLCslRHRUSns+PE2Hw5z1QzRXr4YQ01H7V/wqamZmJpqD+GK4qdvaoJKV4eM5BRMKlag2TdfaaVf/nYlFtUdqPZuu3yXGXfjFmZVq6BvXCbP9Pgbt7B2ynsdS0VRyEhNxcDcLM90UbzMTKzQ1dEjOTkegKSUeKYtCMDI0ITPR2/Bwuz5ELuOjg6rN0/mvTZDaO8XCMDTZ8k8fBSKrbUdqU+TmL9iEJUr1tL00N259xcAtlZ27Duyhr1HVrFw2vObZO6GX6ZyhZqa14qikJL6BHOz3EP7QubQlUg6Ojq4VqrKtUcR6OnqUqWstdafoZ4e5kZlKGdmjo6ODq1qOTHn8B7O3L/D7cePGPXTBipblKV1LSesTUy19i1nmj3xvUpZa4z09almZYtPjTpM3LOFe3Ex7L3+FzsuX6Bvg+eTXO/GxZCpzqJeBbviekvEK+joqLCrasrDiOybEJo0r8y1y7GcPfmQ2MdP2f/zXe6HPqFpi8ooisKW729SoaIJnT6oydPUDFKS00lJTiczQ421TRnqOluzfXMIUZEp3L3zhK0bb+LpXQ4zMwOsrMvwMDKF/T/fJSH+GWdOPuTiHzH4tnk+aT4jI4u4x8+oXEV+AJQ0Kh0dzO2rkhz+AB1dXcrYWGv96ejro2dsjKGFxesL+69nj2MxqVDupelPY2MxLp93emp0DEpWFqZV5NpSEuno6FDd3pX7EdcA2LzzGxKTYhkZuBSVSkViciyJybE8fZZ97eng9yHbihGHigAAHthJREFU9y7iys0TRESFsGj1cCzMbanv2pryNlWp79KGlRsnEB55kxu3z/Lthk9p3sAfC3Mb3J19iY2PZMO2r4h+HM6pCz+zc/9SOr/zsaY+UdF3ycrKpJqdLEadF+mhK6F8atThXFgoHzZq+dq8U9v78/XB3QzaspqktGc0dXDkux6D0MvnQsCL/HszdudG/IJmYW1iyqyOATR44QaKs2GheNhVw8rY5E2bIwpZ7bpW3L3zhOa+dtg7mNM70Im9u0PZufU2FSubMGiEOxUqmRAVmaJZj27qhJNaZXTrVRvvxhX5v7512Ln1NksX/Im+vi4eXuVo9985dnr6OvQf5MxPW0I4evgB1tZG9B5Qjyr2z++QvX83EVMzfa0hX1FyWDvXIyHkDlXb+BVIeWlPnmDt4pRnmjojg8yU1JcGdAm3bmNR3QEDUzlXSiq3ei25cfssHfw+5OSFXTx9lsTYadpPa/BpHMDwfgt5t9VA0tOfsmTNCJ6lpeJSpxmfj9qsWUtueP9FrN3yOZ/P7YyhQRmaer9PQKdPgOx5d599vIHvt89k75FVWJjb0tN/ktYQ7Y3bZ6nl4ImZqVXRvQGliEp58Z7gUuL69evUrfvPH0X1cNqSQqhN4XiQEEerpbP4Y+xXuZ74UNS6rwuii5u3Zki3OFT8fHiRH3Pe0tLziJn4uGfMm3GOKTMaa92cUBx+3HgTy7KGtGlfrdjqMHbokSI9Xts13xbp8d7G09g4Tn8+nebzZqFnZFSsdbkwbxEVGzekUpOGr89cSH7tP/j1mQrY1uCoIj/mm4qJe8DYqX4sn/2n5hFexWX6gm60aNQFn0Zdi60OXQZWeKP93jRu+SdkyLWEsrO0on1dV7b+dbZY63Er+iEPEuJ43zmP5wGJEqOslRHObjZcOPuoWOuRkpzOzWtxNG1R+fWZRbEoY22Frac7D0+dKdZ6JEc85NnjWCo0zL22pig5bK3saODRnmNnthZrPcIjbxITF0Ez787FWo+STAK6Emxym/dZf+EEaZkZxVaHeb/t5asOXfI9fCuKz7uda3D6eCSZGerXZy4kh38Np1U7e60nSYiSx7FrZx78dhx1RvFdW0J3/kztnt3QkWtLidfbfwoHjq0nI6P4liL68ed5DOg2HV1dmSn2MiXinQkODubw4cMATJgwAXf33OsV/RvZmJpxcMiEYq3D8oABxXp8kX9mZgaMmehdrHXo5F/j9ZlEsTMwN6fx1EnFWgfXoR8V6/FF/lmY2zB3ysFircOYgcHFevzSoNgDutu3b3P06FE2bdpEZGQkH3/8Mdu3by/uagkhhBBClBrFPuR6/vx5mjVrhkqlonLlymRlZZGcnFzc1RJCCCGEKDWKPaBLSEjA3Pz5kgfGxsbEx8cXY42EEEIIIUqXYl+2ZOPGjSQnJzNw4EAAOnbsyA8//IDpK9YlunjxIobFvJSHEEIIIUR+pKWlFfr9AcU+h87Ly4uvvvqKgQMHEh4ejp6e3iuDOUBumhBCCCGEeEGxB3SOjo40bNiQHj16oFar+fLLL4u7SkIIIYQQpUqxD7kKIYQQQoi3U+w3RQghhBBCiLcjAZ0QQgghRCknAZ0QQgghSrSinB1WWmeiSUBXzHr37k3t2rW1/urWrYu3tzeBgYGEhIS8tow1a9bQpk0bPDw86N69O2fOvP6h25cuXaJfv354eXnRokULPvvsM1n/rxQorvPl8ePHfPLJJzRo0AAvLy+GDBlCWFhYQTRJFJKCOFdyPHv2jHbt2jFhwusfRXjjxg169uyJq6srPj4+LFu2rER+Qe7bt48+ffrg5eWFh4cH/v7+bNq0iczMzEI/9oMHD6hduzYHD778cVr5yVNQFi9ejJeX12vzJScn07p1a+7evQuAn58fM2bMKOzq8cMPP7Bo0aK3LufYsWO0bt0aFxcXpk+fnmeexYsXs2nTJs3rCRMm8P/+3/9762O/CUVR8Pf35/Tp0/nKX+x3uQqoV68eX3zxheZ1eno6N27cICgoiP79+/Prr79ibGyc576rVq1i/vz5jBw5EicnJ3bv3k1gYCCbN2/Gyckpz31CQkLo3bs3zZs35z//+Q/x8fEsXLiQDz/8kC1btqArD8su0Yr6fElPT6dfv35kZGQwbdo0DAwMmD9/PoGBgezZswcDA4NCaad4e29zrrxo0aJF3Lt3Dw8Pj1fmi42NpV+/fri6uvLtt99y69Yt5s6di56eHh99VHKe3TplyhS2bdtGly5dGDBgAPr6+pw5c4aZM2dy5swZ5s2bV+zXwXLlyrF582YcHByKtR4vmjNnDs2aNSvyOgUHB9OqVau3LmfhwoUYGxuzdOlSqlatmmeeJUuW8Nlnn731sQqCSqXik08+YeLEiezZs4cyZcq8Mr8EdCWAqalprrX1GjRogJGREVOmTOH06dP4+fnl2k9RFNauXUv37t01F8vGjRtz7tw5tm/f/tIv6LVr11KxYkUWLlyouWg5ODjQtWtXTp06RbNmzQq4haIgFfX5sn37dsLDw9m7dy+VKlUCoGLFigwaNIgbN27g6upawC0UBeVNz5UXXblyhU2bNmFtbf3a423atAlFUVi4cCFlypShSZMmPH78mJUrVzJgwIBiD5IAtmzZwpYtW5g6dSrdu3fXbG/atCk1a9bk008/pXXr1nTs2LEYawkGBgYlas3V8PBwtm3bxoEDB4q7Km8sPj4ePz8/mjdvXtxVybcmTZpgYmLCjz/+SJ8+fV6ZV4ZcSzAzMzOAV14Ely9fTmBgoOa1SqXCyMiI1NTUl+5Ts2ZNevXqpVVuzi+uhw8fvm21RTEprPPl0KFD+Pj4aII5gLp163Ls2DEJ5kqp/JwrABkZGUycOJEhQ4Zga2v72nKPHz9Os2bNtHoS2rRpQ0JCAlevXn27SheQFStW4ODgQEBAQK60Tp060bdvX63HUV68eJE+ffrg5uZGgwYN+PTTT4mJidGkT5gwgREjRrBy5UqaNWuGu7s7w4cPJykpiaCgIJo2bUqDBg2YOHEi6enpWscLDw+nR48euLi40K5dO3755RdN2t+HXBcvXoy/vz979uyhXbt2ODs74+/vz/nz57XKPHr0KP7+/ri6utKyZUuCgoLIysrSyrN8+XJatGiBm5sbw4cPJzEx8bXv2+rVq2nYsCEVK1bU2p6Wlsa4ceNwd3enadOmzJ8/H7VarUlXFIVVq1bRpk0bXFxc6NSpE3v37tUq4/fff8ff3x93d3eaNWvGlClTSElJAbKHdSMiIli3bh21a9d+af2SkpL48ssvadKkCS4uLnTt2pXff/9d672MiIhg/fr11K5dmwcPHuQqI6f8WbNm5fqhs27dOvz8/HB1daV79+5cuXJFk9a7d28mTZpEYGAgbm5uzJkzB4Do6GjGjh1LgwYN8PDwYNiwYbmOGxoayqBBg/Dw8MDb25sJEybkmv7UpUsX1q5d+9qpCxLQlQCKopCZman5S01N5c8//2Tx4sVUqlSJ+vXr57mfSqWiXr16VKxYEUVRiI2N5ZtvvuHevXt06dLlpcfr378/vXr10tp29OhRgFf+hxElQ1GfLyEhIdSsWZNFixbRuHFjnJ2dGTRoEFFRUYXVRFFA3vRcyREcHAzAgAED8nW8e/fu5RrKsre3B+D+/ftv0IKC9fDhQ8LCwmjZsiU6Orm//lQqFRMnTqRFixYAXL58mV69eqGjo8P8+fOZNGkSFy5coFevXiQnJ2v2O3nyJPv372f69OmMHz+eQ4cO0bVrV86dO8esWbMYMmQI27dv58cff9Q63rx583Bzc2Pp0qV4enoyZswYzp49+9L6379/nyVLljBy5EgWL17M06dPGTZsGGlpaQCcOnWKIUOGUL58eRYvXsyQIUPYuHEjX331laaM9evXs2DBAgICAli8eDFGRkZs3Ljxle+boigcOHAAHx+fXGnbt28nISGBhQsX0qdPH1auXMnSpUs16UFBQcyZM4c2bdrw7bff0qZNGz799FNNUBceHs7QoUPx9PRk+fLljBs3jkOHDmnqvGTJEmxtbenQoQObN2/Os36ZmZkMGDCAvXv3MmLECJYsWUKlSpUYOHAgR48e1Qxfv1hOuXLlcpWTU37fvn1ZsmSJZvutW7fYvHkz48aNY+7cuURHRzNixAitfXfu3EnlypVZsmQJbdu2JS0tjX79+nH27Fk+++wzFixYwNOnT+nZsydPnjwBsqco9OrVi7CwMGbOnMnMmTO5desWAwYM0Ar+mzVrRkRExGt/FMmQawlw7ty5XMNdZmZmNG/enLFjx772UWgAO3bs0ExY7tatGy4uLvk+/sOHD/n666/x9vaWHpdSoKjPl7i4OLZv346trS2zZs0iNTWVuXPnMnjwYLZt21YihtFE3t7mXLlz5w7BwcGsX78ePb38fVUkJSVpev9y5MzRy08vUGF79OgRAJUrV85X/qVLl1KuXDlWrFiBvr4+AM7OznTq1ImtW7fSr18/AFJSUli6dKmmF3Pnzp3cunWLH3/8ETMzM1q0aMG2bdu4dOkSPXv21JTfrl07xo8fD0Dz5s0JCQkhKCiIBg0a5Fmf5ORk1q1bp/lMnz17xqhRowgJCcHZ2ZmFCxfi6OhIUFCQJmC1s7MjMDCQwMBAKlasyPLlywkICGD48OGa4965c4fw8PCXvg8hISHExMTkOS3D1taWoKAg9PX18fHxISEhgTVr1jBgwACysrJYsWIFvXr1Yty4cUD20HZWVhZz5syhffv2XL16lfT0dIYOHYqVlRWQfc7k9GTVq1cPAwMDbGxsXjoEfeTIES5dusTq1atp2rQpAD4+PnTv3p3//Oc/7Ny5E3d399eWk7O9UqVK1KtXTystKCiIatWqAfDkyRMmT55MZGSkZuTC1NSUL774QnM93Lx5M6GhoWzduhVnZ2cge4pL+/btWb9+PcOHD+e7774jNTWV7du3U6FCBQDq169PmzZt2LNnD507dwagevXqmJubc/LkSU1ZeZEeuhLAycmJrVu38uOPPzJ79mysrKxo0qQJM2fOxM7OLl9l1K9fnw0bNjBhwgR2796dr7vRAKKioujfvz9qtZpZs2a9TTNEESnq8yWnZ2flypW0bNmSDh06sGDBAq5fv86hQ4cKqlmiELzpuaJWq5k0aRIBAQH/+Efe34eF8uoJKy4qlQog3wHqH3/8QZs2bTTBHECNGjWoXbs2Fy5c0GyrXLmy1pC0lZUV1atX1wpuLS0tSUpK0iq/ffv2Wq/9/Py0hvL+Tl9fXyuoyvkMnz59ytOnT/nrr7/o0KEDarVa0ytbv359dHR0OH/+PFFRUcTExODr66v1nrRp0+aV70POVJzy5cvnSmvdurXW+9OqVSuSk5O5d+8eFy9e5NmzZ7z77rtaPcUNGzYkIiKCyMhI3NzcMDIywt/fn9mzZ3P69GlatmypCZbz448//sDCwkITzOXo0KEDN27c0OpNfRPlypXTBHPw/H1/8UeKo6Oj1o/bM2fO4ODgQJ06dTTt1tHRwdPTU9MLe+bMGby8vLCxsdHkMTc3p06dOlo9tSqVinLlyhEREfHKekoPXQlgYmKi6SFxdXXFzs6O3r17o1KpWLhwYb7KqFq1KlWrVsXb2xtdXV1mzJjBuHHjNFF/Xm7dusVHH31Eeno6a9asoUqVKgXSHlG4ivp8MTY2xs3NDQsLC802V1dXzM3NuXXrFm3bti2YhokC96bnyvr163n48CHBwcFay3jkDOG+LCAyNTXVzH3KkfNl+uK8tOKS0zP3qukC0dHRWFtbo6urS1JSUp43g1hZWWkFCSYmJrny/P2OxJxg8kU2NjZ5lvv06dM862ZkZKT1OudzUKvVJCYmolarmTdvHvPmzcuzXTk9lDk9YTleNz8yJ3DJ647ov++bU3ZMTIxmaPHFm0/+Xid3d3fWr1/P0qVL+f7771m9ejXW1taMHj2arl27vrJeL9Yvr88pZ1tKSkq+Ri5extLSUut1zo+UF3+8/L38+Ph4QkND8+zVzJmzHh8fz8WLF/PM8/fP2szMTPN+vowEdCWQl5cXvXr1Yt26dezfv5927drlmS85OZmDBw/SqFEjrS/inK7iqKiolwZ0Fy9e5MMPP8TS0pK1a9eWqFvjxT9T2OdL1apVefbsWa7tmZmZsmRJKZPfc+XgwYNERUXh7e2ttf3GjRvs2LGDQ4cO5dnDV61atVxz5XJe58ylK042NjY4Ojpy/PhxRo8enWeefv36UaFCBVavXo2ZmRmxsbG58sTExFCjRo23rs/fe44eP36MkZHRa5enyIuJiQkqlYphw4bRsmXLXOnly5fX9BD+fdJ9QkLCK8vO+TGXnJycKxjMqw2QHQTl3ByxbNmyPIPG6tWrA2iWuUlLS+P8+fMsXbqUzz//nGbNmuW6CSMv5ubmL/2cVCpVsfyYMDMzw8nJialTp+ZKy7lumpqa4uvry7Bhw3Ll+XuAmJqa+tp2lJy+cKFl+PDhWFhYMHv27Fx3RuVQqVRMnjw510TbU6dOoa+v/9Ig7e7du3z00UdUrFiRTZs2STD3P6Awz5fGjRtz8eJFrTugz5w5Q2pqKm5ubgXXCFEk8nOuTJ06la1bt2r9VatWDV9fX7Zu3ZrnhHKARo0acfz4ca27pg8dOoSlpeVLl8Upan379uXKlSv89NNPudJ27tzJnTt3eO+99wDw9PTkwIEDZGRkaPLcvn2bW7duvXZNvvzIuQsTsnt7fv3113wt8JsXU1NT6taty/3793FxcdH8WVtbs2DBAh49eoSDgwPlypXLtfRIzk1xL5PTs5nTw/ei48ePa/VU7d+/HzMzM+rUqYObmxv6+vrExsZq1enRo0csW7YMyJ5r1rJlS9LT0zE0NKRp06YMHz4ctVqtCTRVKtUr7/D09PTkyZMnnDhxQmv7L7/8Qt26df9RgJxXT+qb8PLyIiwsjMqVK2u1ffv27Rw7dgwAb29v7ty5Q+3atTXp9erVY/Xq1fz5559a5UVHR782uJUeuhLKwsKCwYMHM3v2bNasWcOgQYNy5TExMaF3794EBwdTpkwZnJycOH36NKtWrWLQoEGaX1VhYWHExcVpJnzOmDFDc3dURESE1rh8hQoVXjlMK0qmwjxf+vfvz44dOwgMDGTkyJFkZGQwe/ZsmjRpQsOGDYu0neLt5edcyek5eZGRkRGWlpZaN9Dcvn2b9PR0TS9vjx492LhxIx9//DEDBgwgNDSUNWvWMGbMmBJz88wHH3zAsWPHmDRpEn/99RetWrVCrVZz6tQpNmzYQMeOHTVPBhg6dCg9evTgww8/pG/fviQnJ7NgwQLs7Ozw9/d/67rk3DTh7u7Otm3buHPnDl9++eUblzdixAiGDh2KsbExbdu2JSkpiSVLlpCenk6tWrXQ0dFhxIgRTJkyBSsrKxo1asSePXu4evXqKz+fGjVqUL58ef78889cvbZ3795l9OjRBAQEcOHCBTZu3MjYsWMxNDTE0NCQPn36MHPmTOLi4nBzc+POnTvMnz8fHx8fTExM8PLyIi4ujlGjRtGjRw/S09NZunQpDg4O1KxZE8jugbty5Qpnz57F29s7V9Dl5+eHm5sbY8aMYfTo0VSsWJEdO3Zw6dIlrTtu88Pc3Jzz58/j7u7+VusA+vv7s27dOvr378/AgQOxsrJi165d7Nixg2+//RbQvrb27dsXQ0NDvv/+e06dOqX1/zIyMpL4+HgaN2786oMqolj16tVL6dWrV55paWlpiq+vr+Lh4aFER0fnmScjI0NZvny50rZtW8XJyUl55513lB9++EErz/jx4xVHR0dFURQlOTlZqV27tuLo6Jjn36JFiwq2gaJAFfX5kiMsLEwZNmyY4u7urnh6eirjxo1TEhISCqZRolC87bnyd++9954yfvz4XMfw9fXV2vbXX38pAQEBirOzs9K8eXPl22+/VdRq9Zs1opBkZmYqGzduVLp27ap4eHgoHh4eSufOnZXNmzcrGRkZWnn/+usvpW/fvoqrq6vi7e2tjB8/Xus9Gz9+vPLee+9p7TNkyJBc732vXr2UIUOGKIqiKOHh4Yqjo6Py008/KQEBAYqTk5Py3nvvKSdOnNDkz8lz4MABRVEUZdGiRUr9+vW1yrx27Zri6OionD59WrPt8OHDir+/v+Ls7Kw0atRIGTNmjBIZGam136ZNmxRfX1/FxcVFGTRokBIcHJyr7L+bNm1arjb5+voq8+fPV8aMGaO4uroqPj4+ytq1a7XyqNVqZcWKFUrr1q0VJycnxdfXV5k7d66SlpamyXPixAmlW7duioeHh9KwYUPl448/VsLDwzXpO3fuVBo1aqS4urrmakuOpKQkZdq0aUrjxo0VJycnJSAgQPn9999z1ferr756ZTtXrlyp1K9fX/Hy8lIyMjLy/HxPnz6tODo6KteuXVMURfuzfVFUVJQyZswYxdvbW3Fzc1O6dOmiHDp0SCvP7du3lUGDBmnOw169einnz5/XyrNx40alefPmSlZW1ivrrlKUEviQPSGEEEKUGOHh4bzzzjvs27dPbqArYl27dqVjx4707dv3lflkDp0QQgghXqlKlSp88MEHrFmzprir8q9y8uRJ4uLi6Nat22vzSkAnhBBCiNcaN24cx44d4+7du8VdlX8FRVGYO3cuM2bMyLWMSV5kyFUIIYQQopSTHjohhBBCiFJOAjohhBBCiFJOAjohhBBCiFJOFhYWQhSpCRMm5LlKf47KlStz+PDhIqxR/h09epQvv/ySmJgYPv3009cuIyCEEEVFbooQQhSplJQU0tLSgOznx3bu3JmgoCA8PT0B0NXV1Ty1oqTp0aMHZcqU4csvv6Rs2bJv9cBvIYQoSNJDJ4QoUiYmJpiYmABonvlpZmaW66HfJVF8fDyNGjWShVWFECWOzKETQpQ4Bw8epF69ekRHR2u2KYqCn58fq1ev5syZM7i4uLB7925atmyJq6srgYGBPHjwQJNfrVazePFifHx8cHFxoXPnzhw5cuSVx7148SK9e/fG09OTpk2b8tVXX/H06VMAateuTWhoKEFBQdSuXTvP/Xv37s3kyZPp1KkTnp6eHD16lAkTJhAYGKiV78VtOW05ePAg77zzDu7u7nTv3p2LFy++0XsnhPh3koBOCFHi+Pj4YG5uzp49ezTbzp07x6NHj3jvvfcAyMjIICgoiLlz57J161bS09MZNmwYObNIli1bxrZt25g2bRr79++nd+/ejBkzhnPnzuV5zD///JOePXvi5ubGTz/9xJw5czhy5AijRo0C4NSpU9jb2xMYGMipU6deWvcdO3bw8ccfs3nzZurXr5+v9mZkZBAcHMw333zDTz/9hI6ODqNHj87XvkIIARLQCSFKIH19fTp27MiuXbs023bt2kXz5s2xsbEBsnvspkyZgpeXF46Ojnz99dfcvHmTEydOkJ6ezsqVK5k8eTI+Pj5UqlQJf39/OnfuzPr16/M85po1a3Bzc+OTTz7B3t6eJk2aMH36dH777Tdu3ryJlZUVOjo6lClT5pXDw56enrRt25ZatWrle46doiiMGzcOV1dXHBwc6NOnD5GRkSQmJv6Dd00I8W8mc+iEECWSv78/69ev586dO1SpUoV9+/YxY8YMTbpKpcLb21vzunLlytjY2HDnzh3Kly9Pamoq48aNQ0fn+e/W9PR0qlWrlufxQkJCaNWqldY2T09PVCoVt2/ffukw69/Z2dn9g1Y+9+K8vLJly2rqK4QQ+SEBnRCiRKpXrx61a9dm586dODk5oauri6+vryZdR0dHK1iD7J4uPT09srKyAAgKCsp1A4O+vn6+66AoCoqioKurm+999PS0L6sqlSpXnszMzFzb/t6WnOMLIUR+yJCrEKLE8vf3Z+/evRw6dIiOHTtiYGCgScvKyuLatWua12FhYcTGxlK7dm3s7e3R19cnIiICOzs7zd/PP/+sNYz7opo1a3LhwgWtbTnz7WrVqvXGbTAyMiIlJUVr27179964PCGEyIsEdEKIEqtTp05ERkZy4MABOnfunCv9iy++4MqVK1y/fp1x48bRoEEDvLy8KFOmDL1792bu3Lns27ePyMhItmzZwpIlS3BwcMjzWH379uWvv/5i9uzZ3L9/n1OnTjF16lR8fHyoUaPGG7fBxcWFK1eucODAAR48eMCSJUu4ffv2G5cnhBB5kSFXIUSJZW1tTfPmzYmIiMDZ2TlXeqdOnRg5ciRxcXG0bNmSKVOmaNLGjBmDvr4+M2fOJD4+Hnt7e2bNmkXr1q3zPJaXlxfr169nwYIFdO7cGUtLSzp16sTgwYPfqg3vvfceN2/eZPLkyWRmZtKhQwf69u3LlStX3qpcIYR4kTwpQghRonXu3JmOHTtqreV25swZ+vTpw/Hjx7G1tS3G2gkhRMkgPXRCiBLp4MGDXL58mfDwcPz9/Yu7OkIIUaJJQCeEKJGWL1/Oo0ePmD17tmYZDyGEEHmTIVchhBBCiFJO7nIVQgghhCjlJKATQgghhCjlJKATQgghhCjlJKATQgghhCjlJKATQgghhCjlJKATQgghhCjl/j9etPxaTuo+ZwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "values = [a.round(2) for a in bars2]\n",
    "labels = [\n",
    "    'R 3.2', 'R 3.6', 'R 4.0', \n",
    "    \"Combined (best of three)\"\n",
    "]\n",
    "\n",
    "bins = range(0,len(bars2))\n",
    "\n",
    "plt.figure(figsize=(10,5))\n",
    "sns_plot = sns.barplot(x=bins, y=values, palette=\"husl\", data=temp_df)\n",
    "\n",
    "plt.xticks(bins, labels, rotation=0, fontsize=16)\n",
    "\n",
    "for v, rect in zip(values, sns_plot.patches):\n",
    "    height = rect.get_height()\n",
    "    plt.annotate(\n",
    "        str(v)+\"%\", xy=(\n",
    "            rect.get_x()+rect.get_width()/2-0.1, height+1), rotation=0, color=\"black\", size=14, weight='bold')\n",
    "    \n",
    "for t, rect in zip(totals, ax.patches):\n",
    "    height = rect.get_height()\n",
    "    plt.annotate(\n",
    "        \"(\"+str(t)+\")\", xy=(\n",
    "            rect.get_x()+rect.get_width()/2-0.1, 1.5), rotation=0, color=\"black\", size=14, weight='bold')   \n",
    "\n",
    "plt.ylim(0,55)\n",
    "plt.xlabel(\"Type of run\", size=15)\n",
    "#plt.ylabel(\"Success rate (%)\", size=15)\n",
    "#plt.title(\"Execution success rate of datasets with Python code from Harvard Dataverse\", size=20)\n",
    "\n",
    "\n",
    "# general layout\n",
    "plt.title(\"Execution success rate of datasets with R code from Harvard Dataverse\", fontsize=18)\n",
    "#plt.xticks([r + barWidth/2 for r in range(len(bars1))], ['R 3.2', 'R 3.6', 'R 4.0', 'Combined\\n(best of three)'], fontsize=16)\n",
    "plt.ylabel('Success rate (%)', fontsize=16)\n",
    "#plt.legend(fontsize=16)\n",
    "\n",
    "#plt.tight_layout()\n",
    "plt.savefig(\"all_success_rate.png\", dpi=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "env",
   "language": "python",
   "name": "env"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
